Qtopia library API Documentation
	Overview Class Hierarchy Classes Classes (annotated) Members Source Files Todo

applnk.cpp

/**********************************************************************
** Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
**
** This file is part of the 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.
**
**********************************************************************/

#define QTOPIA_INTERNAL_MIMEEXT
#define QTOPIA_INTERNAL_PRELOADACCESS
#define QTOPIA_INTERNAL_APPLNKASSIGN

#include "applnk.h"

#include <qpe/qpeapplication.h>
#include <qpe/categories.h>
#include <qpe/categoryselect.h>
#include <qpe/qcopenvelope_qws.h>
#include <qpe/global.h>
#include <qpe/mimetype.h>
#include <qpe/config.h>
#include <qpe/storage.h>
#include <qpe/resource.h>

#include <qdict.h>
#include <qdir.h>
#include <qregexp.h>

#include <qgfx_qws.h>

#include <stdlib.h>

int AppLnk::lastId = 5000;

static int smallSize = 14;
static int bigSize = 32;

static QString safeFileName(const QString& n)
{
 QString safename=n;
    safename.replace(QRegExp("[^0-9A-Za-z.]"),"_");
    safename.replace(QRegExp("^[^A-Za-z]*"),"");
    if ( safename.isEmpty() )
  safename = "_";
    return safename;
}

static bool prepareDirectories(const QString& lf)
{
    if ( !QFile::exists(lf) ) {
  // May need to create directories
  QFileInfo fi(lf);
  if ( system(("mkdir -p "+fi.dirPath(TRUE))) )
      return FALSE;
    }
    return TRUE;
}

class AppLnkPrivate
{
public:
    /* the size of the Pixmap */
    enum Size {Normal = 0, Big };
    AppLnkPrivate() {
        /* we want one normal and one big item */

        QPixmap pix;
        mPixmaps.insert(0, pix );
        mPixmaps.insert(1,  pix);
    }

    QStringList mCatList; // always correct
    QArray<int> mCat; // cached value; correct if not empty
    QMap<int,  QPixmap> mPixmaps;

    void updateCatListFromArray()
    {
  Categories cat( 0 );
  cat.load( categoryFileName() );
  // we need to update the names for the mCat... to mCatList
        mCatList.clear();
        for (uint i = 0; i < mCat.count(); i++ )
            mCatList << cat.label("Document View", mCat[i] );

    }

    void setCatArrayDirty()
    {
  mCat.resize(0);
    }

    void ensureCatArray()
    {
  if ( mCat.count() > 0 || mCatList.count()==0 )
      return;

  Categories cat( 0 );
  cat.load( categoryFileName() );
  mCat.resize( mCatList.count() );
  int i;
  QStringList::ConstIterator it;
  for ( i = 0, it = mCatList.begin(); it != mCatList.end();
        ++it, i++ ) {

      bool number;
      int id = (*it).toInt( &number );
      if ( !number ) {
    id = cat.id( "Document View", *it );
    if ( id == 0 )
        id = cat.addCategory( "Document View", *it );
      }
      mCat[i] = id;
  }
    }
};

void AppLnk::setSmallIconSize(int small)
{
    smallSize = small;
}

int AppLnk::smallIconSize()
{
    return smallSize;
}


void AppLnk::setBigIconSize(int big)
{
    bigSize = big;
}

int AppLnk::bigIconSize()
{
    return bigSize;
}


const QArray<int>& AppLnk::categories() const
{
    d->ensureCatArray();
    return d->mCat;
}

AppLnk::AppLnk()
{
    mId = 0;
    d = new AppLnkPrivate();
}

AppLnk::AppLnk( const QString &file )
{
    QStringList sl;
    d = new AppLnkPrivate();
    if ( !file.isNull() ) {
  Config config( file, Config::File );

  if ( config.isValid() ) {
      config.setGroup( "Desktop Entry" );

      mName = config.readEntry( "Name", file );
      mExec = config.readEntry( "Exec" );
      mType = config.readEntry( "Type", QString::null );
      mIconFile = config.readEntry( "Icon", QString::null );
      mRotation = config.readEntry( "Rotation", "" );
      mComment = config.readEntry( "Comment", QString::null );
      // MIME types are case-insensitive.
      mMimeTypes = config.readListEntry( "MimeType", ';' );
      for (QStringList::Iterator it=mMimeTypes.begin(); it!=mMimeTypes.end(); ++it)
    *it = (*it).lower();
      mMimeTypeIcons = config.readListEntry( "MimeTypeIcons", ';' );
      mLinkFile = file;
      mFile = config.readEntry("File", QString::null);
      if ( !mExec. isEmpty ( )) {
    mFile = QString::null;
      }
      else if ( mFile[0] != '/' ) {
    int slash = file.findRev('/');
    if ( slash >= 0 ) {
        mFile = file.left(slash) + '/' + mFile;
    }
      }
      d->mCatList = config.readListEntry("Categories", ';');
      if ( d->mCatList[0].toInt() < -1 ) {
    // numeric cats in file! convert to text
    Categories cat( 0 );
    cat.load( categoryFileName() );
    d->mCat.resize( d->mCatList.count() );
    int i;
    QStringList::ConstIterator it;
    for ( i = 0, it = d->mCatList.begin(); it != d->mCatList.end();
          ++it, i++ ) {
        bool number;
        int id = (*it).toInt( &number );
        if ( !number ) {
      // convert from text
      id = cat.id( "Document View", *it );
      if ( id == 0 )
          id = cat.addCategory( "Document View", *it );
        }
        d->mCat[i] = id;
    }
    d->updateCatListFromArray();
      }
  }
    }
    mId = 0;
}

AppLnk& AppLnk::operator=(const AppLnk &copy)
{
    if ( this == &copy ) return *this;
    if ( mId )
  qWarning("Deleting AppLnk that is in an AppLnkSet");
    if ( d )
  delete d;


    mName = copy.mName;

    /* remove for Qtopia 3.0 -zecke */
    mPixmap = copy.mPixmap;
    mBigPixmap = copy.mBigPixmap;

    mExec = copy.mExec;
    mType = copy.mType;
    mRotation = copy.mRotation;
    mComment = copy.mComment;
    mFile = copy.mFile;
    mLinkFile = copy.mLinkFile;
    mIconFile = copy.mIconFile;
    mMimeTypes = copy.mMimeTypes;
    mMimeTypeIcons = copy.mMimeTypeIcons;
    mId = 0;
    d = new AppLnkPrivate();
    d->mCat = copy.d->mCat;
    d->mCatList = copy.d->mCatList;
    d->mPixmaps = copy.d->mPixmaps;

    return *this;
}
const QPixmap& AppLnk::pixmap( int pos, int size ) const {
    if ( d->mPixmaps[pos].isNull() ) {
  AppLnk* that = (AppLnk*)this;
  if ( mIconFile.isEmpty() ) {
      MimeType mt(type());
      that->d->mPixmaps[pos] = pos ? mt.bigPixmap() : mt.pixmap();
      if ( that->d->mPixmaps[pos].isNull() )
    that->d->mPixmaps[pos].convertFromImage(
        Resource::loadImage("UnknownDocument")
      .smoothScale( size, size ) );
      return that->d->mPixmaps[pos];
  }
  QImage unscaledIcon = Resource::loadImage( that->mIconFile );
  if ( unscaledIcon.isNull() ) {
    //  qDebug( "Cannot find icon: %s", that->mIconFile.latin1() );
      that->d->mPixmaps[pos].convertFromImage(
        Resource::loadImage("UnknownDocument")
      .smoothScale( size, size ) );
  } else {
      that->d->mPixmaps[0].convertFromImage( unscaledIcon.smoothScale( smallSize, smallSize ) );
      that->d->mPixmaps[1].convertFromImage( unscaledIcon.smoothScale( bigSize, bigSize ) );
  }
  return that->d->mPixmaps[pos];
    }
    return d->mPixmaps[pos];
}

const QPixmap& AppLnk::pixmap() const
{
    if ( d->mPixmaps[0].isNull() ) {
        return pixmap(AppLnkPrivate::Normal, smallSize );
    }
    return d->mPixmaps[0];
}

const QPixmap& AppLnk::bigPixmap() const
{
    if ( d->mPixmaps[1].isNull() ) {
        return pixmap( AppLnkPrivate::Big, bigSize );
    }
    return d->mPixmaps[1];
}

QString AppLnk::type() const
{
    if ( mType.isNull() ) {
  AppLnk* that = (AppLnk*)this;
  QString f = file();
  if ( !f.isNull() ) {
      MimeType mt(f);
      that->mType = mt.id();
      return that->mType;
  }
    }
    return mType;
}

QString AppLnk::file() const
{
    if ( mExec.isEmpty ( ) && mFile.isNull() ) {
  AppLnk* that = (AppLnk*)this;
  QString ext = MimeType(mType).extension();
  if ( !ext.isEmpty() )
      ext = "." + ext;
  if ( !mLinkFile.isEmpty() ) {
      that->mFile =
    mLinkFile.right(8)==".desktop" // 8 = strlen(".desktop")
        ? mLinkFile.left(mLinkFile.length()-8) : mLinkFile;
  qDebug("mFile now == %s", mFile.latin1());
  } else if ( mType.contains('/') ) {
      that->mFile =
    QString(getenv("HOME"))+"/Documents/"+mType+"/"+safeFileName(that->mName);
            /*
             * A file with the same name or a .desktop file already exists
             */
      if ( QFile::exists(that->mFile+ext) || QFile::exists(that->mFile+".desktop") ) {
    int n=1;
    QString nn;
    while (QFile::exists((nn=(that->mFile+"_"+QString::number(n)))+ext)
      || QFile::exists(nn+".desktop"))
        n++;
    that->mFile = nn;
      }
      that->mLinkFile = that->mFile+".desktop";
      that->mFile += ext;
  }
  prepareDirectories(that->mFile);
  if ( !that->mFile.isEmpty() ) {
      QFile f(that->mFile);
      if ( !f.open(IO_WriteOnly) )
    that->mFile = QString::null;
      return that->mFile;
  }
    }
    return mFile;
}

QString AppLnk::linkFile() const
{
    if ( mLinkFile.isNull() ) {
  AppLnk* that = (AppLnk*)this;
  if ( type().contains('/') ) {
      StorageInfo storage;
      const FileSystem *fs = storage.fileSystemOf( that->mFile );
            /* tmpfs + and ramfs are available too but not removable
             * either we fix storage or add this
             */
      if ( fs && ( fs->isRemovable() || fs->disk() == "/dev/mtdblock6" || fs->disk() == "tmpfs") ) {
    that->mLinkFile = fs->path();
      } else
    that->mLinkFile = getenv( "HOME" );
      that->mLinkFile += "/Documents/"+type()+"/"+safeFileName(that->mName);

            /* the desktop file exists make sure we don't point to the same file */
      if ( QFile::exists(that->mLinkFile+".desktop") ) {
                AppLnk lnk( that->mLinkFile + ".desktop" );

                /* the linked is different */
                if(that->file() != lnk.file() ) {
                    int n = 1;
                    QString nn;
                    while (QFile::exists((nn=that->mLinkFile+"_"+QString::number(n))+".desktop")) {
                        n++;
                        /* just to be sure */
                        AppLnk lnk(nn );
                        if (lnk.file() == that->file() )
                            break;
                    }
                    that->mLinkFile = nn;
                }
      }
      that->mLinkFile += ".desktop";
      storeLink();
  }
  return that->mLinkFile;
    }
    return mLinkFile;
}

AppLnk::AppLnk( const AppLnk &copy )
{
    mName = copy.mName;
    mPixmap = copy.mPixmap;
    mBigPixmap = copy.mBigPixmap;
    mExec = copy.mExec;
    mType = copy.mType;
    mRotation = copy.mRotation;
    mComment = copy.mComment;
    mFile = copy.mFile;
    mLinkFile = copy.mLinkFile;
    mIconFile = copy.mIconFile;
    mMimeTypes = copy.mMimeTypes;
    mMimeTypeIcons = copy.mMimeTypeIcons;
    mId = 0;
    d = new AppLnkPrivate();
    d->mCat = copy.d->mCat;
    d->mCatList = copy.d->mCatList;
    d->mPixmaps = copy.d->mPixmaps;
}

AppLnk::~AppLnk()
{
    if ( mId )
  qWarning("Deleting AppLnk that is in an AppLnkSet");
    if ( d )
  delete d;
}

void AppLnk::execute() const
{
    execute(QStringList());
}

void AppLnk::execute(const QStringList& args) const
{
#ifdef Q_WS_QWS
    if ( !mRotation.isEmpty() ) {
  // ######## this will only work in the server
  int rot = QPEApplication::defaultRotation();
  rot = (rot+mRotation.toInt())%360;
  QCString old = getenv("QWS_DISPLAY");
  setenv("QWS_DISPLAY", QString("Transformed:Rot%1:0").arg(rot), 1);
  invoke(args);
  setenv("QWS_DISPLAY", old.data(), 1);
    } else
#endif
  invoke(args);
}

void AppLnk::invoke(const QStringList& args) const
{
    Global::execute( exec(), args[0] );
}

void AppLnk::setExec( const QString& exec )
{
    mExec = exec;
}

#if 0 // this was inlined for better BC

void AppLnk::setRotation ( const QString &rot )
{
  mRotation = rot;
}
#endif

void AppLnk::setName( const QString& docname )
{
    mName = docname;
}

void AppLnk::setFile( const QString& filename )
{
    mFile = filename;
}

void AppLnk::setLinkFile( const QString& filename )
{
    mLinkFile = filename;
}

void AppLnk::setComment( const QString& comment )
{
    mComment = comment;
}

void AppLnk::setType( const QString& type )
{
    mType = type;
}

void AppLnk::setIcon( const QString& iconname )
{
    mIconFile = iconname;
    QImage unscaledIcon = Resource::loadImage( mIconFile );
    d->mPixmaps[0].convertFromImage( unscaledIcon.smoothScale( smallSize, smallSize ) );
    d->mPixmaps[1].convertFromImage( unscaledIcon.smoothScale( bigSize, bigSize ) );
}

void AppLnk::setCategories( const QArray<int>& c )
{
    d->mCat = c;
    d->updateCatListFromArray();
}

bool AppLnk::ensureLinkExists() const
{
    QString lf = linkFile();
    return prepareDirectories(lf);
}

bool AppLnk::writeLink() const
{
    // Only re-writes settable parts
    QString lf = linkFile();
    if ( !ensureLinkExists() )
  return FALSE;
    storeLink();
    return TRUE;
}

void AppLnk::storeLink() const
{
    Config config( mLinkFile, Config::File );
    config.setGroup("Desktop Entry");
    config.writeEntry("Name",mName);
    if ( !mIconFile.isNull() ) config.writeEntry("Icon",mIconFile);
    config.writeEntry("Type",type());
    if(!rotation().isEmpty())
  config.writeEntry("Rotation",rotation());
    else
  config.removeEntry("Rotation");
    if ( !mComment.isNull() ) config.writeEntry("Comment",mComment);
    QString f = file();
    int i = 0;
    while ( i < (int)f.length() && i < (int)mLinkFile.length() && f[i] == mLinkFile[i] )
  i++;
    while ( i && f[i] != '/' )
  i--;
    // simple case where in the same directory
    if ( mLinkFile.find( '/', i + 1 ) < 0 )
  f = f.mid(i+1);
    // ### could do relative ie ../../otherDocs/file.doc
    config.writeEntry("File",f);
    config.writeEntry( "Categories", d->mCatList, ';' );

#ifndef QT_NO_COP
    QCopEnvelope e("QPE/System", "linkChanged(QString)");
    e << mLinkFile;
#endif
}

void AppLnk::setProperty(const QString& key, const QString& value)
{
    if ( ensureLinkExists() ) {
  Config cfg(linkFile(), Config::File);
  cfg.writeEntry(key,value);
    }
}

QString AppLnk::property(const QString& key) const
{
    QString lf = linkFile();
    if ( !QFile::exists(lf) )
  return QString::null;
    Config cfg(lf, Config::File);
    return cfg.readEntry(key);
}

bool AppLnk::isPreloaded() const {
  // Preload information is stored in the Launcher config in v1.5.
  Config cfg("Launcher");
  cfg.setGroup("Preload");
  QStringList apps = cfg.readListEntry("Apps",',');
  if (apps.contains(exec()))
    return true;
  return false;
}

void AppLnk::setPreloaded(bool yesNo) {
  // Preload information is stored in the Launcher config in v1.5.
  Config cfg("Launcher");
  cfg.setGroup("Preload");
  QStringList apps = cfg.readListEntry("Apps", ',');
  if (apps.contains(exec()) && !yesNo)
    apps.remove(exec());
  else if (yesNo && !apps.contains(exec()))
    apps.append(exec());
  cfg.writeEntry("Apps", apps, ',');
}


void AppLnk::removeFiles()
{
    bool valid = isValid();
    if ( !valid || !linkFileKnown() || QFile::remove(linkFile()) ) {
  if ( QFile::remove(file()) ) {
#ifndef QT_NO_COP
      QCopEnvelope e("QPE/System", "linkChanged(QString)");
      if ( linkFileKnown() )
    e << linkFile();
      else
    e << file();
#endif
  } else if ( valid ) {
      // restore link
      writeLink();
  }
    }
}

void AppLnk::removeLinkFile()
{
    if ( isValid() && linkFileKnown() && QFile::remove(linkFile()) ) {
#ifndef QT_NO_COP
  QCopEnvelope e("QPE/System", "linkChanged(QString)");
  e << linkFile();
#endif
    }
}

class AppLnkSetPrivate {
public:
    AppLnkSetPrivate()
    {
  typPix.setAutoDelete(TRUE);
  typPixBig.setAutoDelete(TRUE);
  typName.setAutoDelete(TRUE);
    }

    QDict<QPixmap> typPix;
    QDict<QPixmap> typPixBig;
    QDict<QString> typName;
};

AppLnkSet::AppLnkSet() :
    d(new AppLnkSetPrivate)
{
}

AppLnkSet::AppLnkSet( const QString &directory ) :
    d(new AppLnkSetPrivate)
{
    QDir dir( directory );
    mFile = directory;
    findChildren(directory,QString::null,QString::null);
}

void AppLnkSet::detachChildren()
{
    QListIterator<AppLnk> it( mApps );
    for ( ; it.current(); ) {
  AppLnk* a = *it;
  ++it;
  a->mId = 0;
    }
    mApps.clear();
}

AppLnkSet::~AppLnkSet()
{
    QListIterator<AppLnk> it( mApps );
    for ( ; it.current(); ) {
  AppLnk* a = *it;
  ++it;
  a->mId = 0;
  delete a;
    }
    delete d;
}

void AppLnkSet::findChildren(const QString &dr, const QString& typ, const QString& typName, int depth)
{
    depth++;
    if ( depth > 10 )
  return;

    QDir dir( dr );
    QString typNameLocal = typName;

    if ( dir.exists( ".directory" ) ) {
  Config config( dr + "/.directory", Config::File );
  config.setGroup( "Desktop Entry" );
  typNameLocal = config.readEntry( "Name", typNameLocal );
  if ( !typ.isEmpty() ) {
      QString iconFile = config.readEntry( "Icon", "AppsIcon" );
      QImage unscaledIcon = Resource::loadImage( iconFile );
      QPixmap pm, bpm;
      pm.convertFromImage( unscaledIcon.smoothScale( smallSize, smallSize ) );
      bpm.convertFromImage( unscaledIcon.smoothScale( bigSize, bigSize ) );
      d->typPix.insert(typ, new QPixmap(pm));
      d->typPixBig.insert(typ, new QPixmap(bpm));
      d->typName.insert(typ, new QString(typNameLocal));
  }
    }

    const QFileInfoList *list = dir.entryInfoList();
    if ( list ) {
  QFileInfo* fi;
  bool cadded=FALSE;
  for ( QFileInfoListIterator it(*list); (fi=*it); ++it ) {
      QString bn = fi->fileName();
//      qDebug("findChildren "+bn);
      if ( bn[0] != '.' && bn != "CVS" ) {
    if ( fi->isDir() ) {
        QString c = typ.isNull() ? bn : typ+"/"+bn;
        QString d = typNameLocal.isNull() ? bn : typNameLocal+"/"+bn;
        findChildren(fi->filePath(), c, d, depth );
    } else {
        if ( fi->extension(FALSE) == "desktop" ) {
      AppLnk* app = new AppLnk( fi->filePath() );
#ifdef QT_NO_QWS_MULTIPROCESS
      if ( !Global::isBuiltinCommand( app->exec() ) )
          delete app;
      else
#endif
      {
          if ( !typ.isEmpty() ) {
        if ( !cadded ) {
            typs.append(typ);
            cadded = TRUE;
        }
        app->setType(typ);
          }
          add(app);
      }
        }
    }
      }
  }
    }
}

void AppLnkSet::add( AppLnk *f )
{
    if ( f->mId == 0 ) {
  AppLnk::lastId++;
  f->mId = AppLnk::lastId;
  mApps.append( f );
    } else {
  qWarning("Attempt to add an AppLnk twice");
    }
}

bool AppLnkSet::remove( AppLnk *f )
{
    if ( mApps.remove( f ) ) {
  f->mId = 0;
  return TRUE;
    }
    return FALSE;
}


QString AppLnkSet::typeName( const QString& t ) const
{
    QString *st = d->typName.find(t);
    return st ? *st : QString::null;
}

QPixmap AppLnkSet::typePixmap( const QString& t ) const
{
    QPixmap *pm = d->typPix.find(t);
    return pm ? *pm : QPixmap();
}

QPixmap AppLnkSet::typeBigPixmap( const QString& t ) const
{
    QPixmap *pm = d->typPixBig.find(t);
    return pm ? *pm : QPixmap();
}

const AppLnk *AppLnkSet::find( int id ) const
{
    QListIterator<AppLnk> it( children() );

    for ( ; it.current(); ++it ) {
  const AppLnk *app = it.current();
  if ( app->id() == id )
      return app;
    }

    return 0;
}

const AppLnk *AppLnkSet::findExec( const QString& exec ) const
{
    QListIterator<AppLnk> it( children() );

    for ( ; it.current(); ++it ) {
  const AppLnk *app = it.current();
  if ( app->exec() == exec )
      return app;
    }

    return 0;
}

DocLnkSet::DocLnkSet()
{
}

DocLnkSet::DocLnkSet( const QString &directory, const QString& mimefilter ) :
    AppLnkSet()
{
    QDir dir( directory );
    mFile = dir.dirName();
    QDict<void> reference;

    QStringList subFilter = QStringList::split(";", mimefilter);
    QValueList<QRegExp> mimeFilters;
    for( QStringList::Iterator it = subFilter.begin(); it != subFilter.end(); ++ it )
  mimeFilters.append( QRegExp(*it, FALSE, TRUE) );

    findChildren(directory, mimeFilters, reference);

    const QList<DocLnk> &list = children();
    for ( QListIterator<DocLnk> it( list ); it.current(); ++it ) {
  reference.remove( (*it)->file() );
    }
    for ( QDictIterator<void> dit(reference); dit.current(); ++dit ) {
  if ( dit.current() == (void*)2 ) {
      // Unreferenced, make an unwritten link
      DocLnk* dl = new DocLnk;
      QFileInfo fi( dit.currentKey() );
      dl->setFile(fi.filePath());
      dl->setName(fi.baseName());
      // #### default to current path?
      // dl->setCategories( ... );
      bool match = mimefilter.isNull();
      if ( !match )
    for( QValueList<QRegExp>::Iterator it = mimeFilters.begin(); it != mimeFilters.end() && !match; ++ it )
        if ( (*it).match(dl->type()) >= 0 )
      match = TRUE;
      if ( match /* && dl->type() != "application/octet-stream" */
        && !!dl->exec() )
    add(dl);
      else
    delete dl;
  }
    }
}

// other becomes empty
void DocLnkSet::appendFrom( DocLnkSet& other )
{
    if ( &other == this )
  return;
    QListIterator<AppLnk> it( other.mApps );
    for ( ; it.current(); ) {
  mApps.append(*it);
  ++it;
    }
    other.mApps.clear();
}

void DocLnkSet::findChildren(const QString &dr, const QValueList<QRegExp> &mimeFilters, QDict<void> &reference, int depth)
{
    depth++;
    if ( depth > 10 )
  return;

    QDir dir( dr );

    /* Opie got a different approach
     * I guess it's geek vs. consumer
     * in this case to be discussed
     */
    if ( dir.exists( ".Qtopia-ignore" ) )
  return;

    const QFileInfoList *list = dir.entryInfoList();
    if ( list ) {
  QFileInfo* fi;
  for ( QFileInfoListIterator it(*list); (fi=*it); ++it ) {
      QString bn = fi->fileName();
      if ( bn[0] != '.' ) {
    if ( fi->isDir()  ) {
        if ( bn != "CVS" && bn != "Qtopia" && bn != "QtPalmtop" )
      findChildren(fi->filePath(), mimeFilters, reference, depth);
    } else {
        if ( fi->extension(FALSE) == "desktop" ) {
      DocLnk* dl = new DocLnk( fi->filePath() );
      QFileInfo fi2(dl->file());
      bool match = FALSE;
      if ( !fi2.exists() ) {
          dir.remove( dl->file() );
      }
      if ( mimeFilters.count() == 0 ) {
          add( dl );
          match = TRUE;
      } else {
          for( QValueList<QRegExp>::ConstIterator it = mimeFilters.begin(); it != mimeFilters.end(); ++ it ) {
        if ( (*it).match(dl->type()) >= 0 ) {
            add(dl);
            match = TRUE;
        }
          }
      }
      if ( !match )
          delete dl;
        } else {
      if ( !reference.find(fi->fileName()) )
          reference.insert(fi->filePath(), (void*)2);
        }
    }
      }
  }
    }
}

DocLnk::DocLnk( const QString &file ) :
    AppLnk(file)
{
    init(file);
}

DocLnk::DocLnk( const QString &file, bool may_be_desktopfile ) :
    AppLnk(may_be_desktopfile ? file : QString::null)
{
    init(file);
}

void DocLnk::init(const QString &file)
{
    if ( isValid() ) {
#ifndef FORCED_DIR_STRUCTURE_WAY
  if ( mType.isNull() )
      // try to infer it
#endif
  {
      int s0 = file.findRev('/');
      if ( s0 > 0 ) {
    int s1 = file.findRev('/',s0-1);
    if ( s1 > 0 ) {
        int s2 = file.findRev('/',s1-1);
        if ( s2 > 0 ) {
      mType = file.mid(s2+1,s0-s2-1);
        }
    }
      }
  }
    } else if ( QFile::exists(file) ) {
  QString n = file;
  n.replace(QRegExp(".*/"),"");
  n.replace(QRegExp("\\..*"),"");
  setName( n );
  setFile( file );
    }
    MimeType mt(mType);
    if( mt.application() )
  mExec = mt.application()->exec();
}

DocLnk::DocLnk()
{
}

DocLnk::~DocLnk()
{
}

QString DocLnk::exec() const
{
    MimeType mt(type());
    const AppLnk* app = mt.application();
    if ( app )
  return app->exec();
    else
  return QString::null;
}

void DocLnk::invoke(const QStringList& args) const
{
    MimeType mt(type());
    const AppLnk* app = mt.application();
    if ( app ) {
  QStringList a = args;
  if ( linkFileKnown() && QFile::exists( linkFile() ) )
      a.append(linkFile());
  else
      a.append(file());
  app->execute(a);
    }
}

This file is part of the documentation for OPIE Version 1.5.5.

Documentation copyright © 1997-2003 the KDE developers. 2003 OPIE developers
Generated on Tue Feb 10 20:24:03 2004 by doxygen 1.3.5 written by Dimitri van Heesch, © 1997-2001