00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021 #include <config.h>
00022
00023 #include <sys/types.h>
00024 #include <sys/stat.h>
00025
00026 #include <assert.h>
00027 #include <dirent.h>
00028 #include <errno.h>
00029 #include <stddef.h>
00030 #include <unistd.h>
00031 #include <stdlib.h>
00032
00033 #include <kprotocolinfo.h>
00034 #include <kio/global.h>
00035 #include "kmimetype.h"
00036 #include "kservicetypefactory.h"
00037 #include "kmimemagic.h"
00038 #include "kservice.h"
00039 #include "krun.h"
00040 #include "kautomount.h"
00041 #include <kdirnotify_stub.h>
00042
00043 #include <qstring.h>
00044 #include <qfile.h>
00045 #include <kmessageboxwrapper.h>
00046
00047 #include <dcopclient.h>
00048 #include <dcopref.h>
00049 #include <kapplication.h>
00050 #include <kprocess.h>
00051 #include <kdebug.h>
00052 #include <kdesktopfile.h>
00053 #include <kdirwatch.h>
00054 #include <kiconloader.h>
00055 #include <klocale.h>
00056 #include <ksimpleconfig.h>
00057 #include <kstandarddirs.h>
00058 #include <kurl.h>
00059 #include <ksycoca.h>
00060 #include <kde_file.h>
00061
00062 template class KSharedPtr<KMimeType>;
00063 template class QValueList<KMimeType::Ptr>;
00064
00065 KMimeType::Ptr KMimeType::s_pDefaultType = 0L;
00066 bool KMimeType::s_bChecked = false;
00067
00068 void KMimeType::buildDefaultType()
00069 {
00070 assert ( !s_pDefaultType );
00071
00072 KServiceType * mime = KServiceTypeFactory::self()->
00073 findServiceTypeByName( defaultMimeType() );
00074
00075 if (mime && mime->isType( KST_KMimeType ))
00076 {
00077 s_pDefaultType = KMimeType::Ptr((KMimeType *) mime);
00078 }
00079 else
00080 {
00081 errorMissingMimeType( defaultMimeType() );
00082 KStandardDirs stdDirs;
00083 QString sDefaultMimeType = stdDirs.resourceDirs("mime").first()+defaultMimeType()+".desktop";
00084 s_pDefaultType = new KMimeType( sDefaultMimeType, defaultMimeType(),
00085 "unknown", "mime", QStringList() );
00086 }
00087 }
00088
00089 KMimeType::Ptr KMimeType::defaultMimeTypePtr()
00090 {
00091 if ( !s_pDefaultType )
00092 buildDefaultType();
00093 return s_pDefaultType;
00094 }
00095
00096
00097 void KMimeType::checkEssentialMimeTypes()
00098 {
00099 if ( s_bChecked )
00100 return;
00101 if ( !s_pDefaultType )
00102 buildDefaultType();
00103
00104 s_bChecked = true;
00105
00106
00107
00108 if ( !KServiceTypeFactory::self()->checkMimeTypes() )
00109 {
00110 KMessageBoxWrapper::error( 0L, i18n( "No mime types installed." ) );
00111 return;
00112 }
00113
00114 if ( KMimeType::mimeType( "inode/directory" ) == s_pDefaultType )
00115 errorMissingMimeType( "inode/directory" );
00116 if ( KMimeType::mimeType( "inode/directory-locked" ) == s_pDefaultType )
00117 errorMissingMimeType( "inode/directory-locked" );
00118 if ( KMimeType::mimeType( "inode/blockdevice" ) == s_pDefaultType )
00119 errorMissingMimeType( "inode/blockdevice" );
00120 if ( KMimeType::mimeType( "inode/chardevice" ) == s_pDefaultType )
00121 errorMissingMimeType( "inode/chardevice" );
00122 if ( KMimeType::mimeType( "inode/socket" ) == s_pDefaultType )
00123 errorMissingMimeType( "inode/socket" );
00124 if ( KMimeType::mimeType( "inode/fifo" ) == s_pDefaultType )
00125 errorMissingMimeType( "inode/fifo" );
00126 if ( KMimeType::mimeType( "application/x-shellscript" ) == s_pDefaultType )
00127 errorMissingMimeType( "application/x-shellscript" );
00128 if ( KMimeType::mimeType( "application/x-executable" ) == s_pDefaultType )
00129 errorMissingMimeType( "application/x-executable" );
00130 if ( KMimeType::mimeType( "application/x-desktop" ) == s_pDefaultType )
00131 errorMissingMimeType( "application/x-desktop" );
00132 }
00133
00134 void KMimeType::errorMissingMimeType( const QString& _type )
00135 {
00136 QString tmp = i18n( "Could not find mime type\n%1" ).arg( _type );
00137
00138 KMessageBoxWrapper::sorry( 0, tmp );
00139 }
00140
00141 KMimeType::Ptr KMimeType::mimeType( const QString& _name )
00142 {
00143 KServiceType * mime = KServiceTypeFactory::self()->findServiceTypeByName( _name );
00144
00145 if ( !mime || !mime->isType( KST_KMimeType ) )
00146 {
00147
00148
00149 if ( !KSycoca::self()->isBuilding() )
00150 delete mime;
00151 if ( !s_pDefaultType )
00152 buildDefaultType();
00153 return s_pDefaultType;
00154 }
00155
00156
00157 return KMimeType::Ptr((KMimeType *) mime);
00158 }
00159
00160 KMimeType::List KMimeType::allMimeTypes()
00161 {
00162 return KServiceTypeFactory::self()->allMimeTypes();
00163 }
00164
00165 KMimeType::Ptr KMimeType::findByURL( const KURL& _url, mode_t _mode,
00166 bool _is_local_file, bool _fast_mode )
00167 {
00168 checkEssentialMimeTypes();
00169 QString path = _url.path();
00170
00171 if ( !_fast_mode && !_is_local_file && _url.isLocalFile() )
00172 _is_local_file = true;
00173
00174 if ( !_fast_mode && _is_local_file && (_mode == 0 || _mode == (mode_t)-1) )
00175 {
00176 KDE_struct_stat buff;
00177 if ( KDE_stat( QFile::encodeName(path), &buff ) != -1 )
00178 _mode = buff.st_mode;
00179 }
00180
00181
00182 if ( S_ISDIR( _mode ) )
00183 {
00184
00185
00186 if ( _is_local_file )
00187 {
00188 if ( access( QFile::encodeName(path), R_OK ) == -1 )
00189 return mimeType( "inode/directory-locked" );
00190 }
00191 return mimeType( "inode/directory" );
00192 }
00193 if ( S_ISCHR( _mode ) )
00194 return mimeType( "inode/chardevice" );
00195 if ( S_ISBLK( _mode ) )
00196 return mimeType( "inode/blockdevice" );
00197 if ( S_ISFIFO( _mode ) )
00198 return mimeType( "inode/fifo" );
00199 if ( S_ISSOCK( _mode ) )
00200 return mimeType( "inode/socket" );
00201
00202 if ( !_is_local_file && S_ISREG( _mode ) && ( _mode & ( S_IXUSR | S_IXGRP | S_IXOTH ) ) )
00203 return mimeType( "application/x-executable" );
00204
00205 QString fileName ( _url.fileName() );
00206
00207 static const QString& slash = KGlobal::staticQString("/");
00208 if ( ! fileName.isNull() && !path.endsWith( slash ) )
00209 {
00210
00211 KMimeType::Ptr mime = KServiceTypeFactory::self()->findFromPattern( fileName );
00212 if ( mime )
00213 {
00214
00215 if ( _is_local_file || _url.hasSubURL() ||
00216 KProtocolInfo::determineMimetypeFromExtension( _url.protocol() ) )
00217 {
00218 if ( _is_local_file && !_fast_mode ) {
00219 if ( mime->patternsAccuracy()<100 )
00220 {
00221 KMimeMagicResult* result =
00222 KMimeMagic::self()->findFileType( path );
00223
00224 if ( result && result->isValid() )
00225 return mimeType( result->mimeType() );
00226 }
00227 }
00228
00229 return mime;
00230 }
00231 }
00232
00233 static const QString& dotdesktop = KGlobal::staticQString(".desktop");
00234 static const QString& dotkdelnk = KGlobal::staticQString(".kdelnk");
00235 static const QString& dotdirectory = KGlobal::staticQString(".directory");
00236
00237
00238 if ( fileName.endsWith( dotdesktop ) )
00239 return mimeType( "application/x-desktop" );
00240
00241
00242 if ( fileName.endsWith( dotkdelnk ) )
00243 return mimeType( "application/x-desktop" );
00244
00245
00246 if ( fileName == dotdirectory )
00247 return mimeType( "text/plain" );
00248 }
00249
00250 if ( !_is_local_file || _fast_mode )
00251 {
00252 QString def = KProtocolInfo::defaultMimetype( _url );
00253 if ( !def.isEmpty() && def != defaultMimeType() )
00254 {
00255
00256 return mimeType( def );
00257 }
00258 if ( path.endsWith( slash ) || path.isEmpty() )
00259 {
00260
00261
00262
00263
00264 if ( def.isEmpty() )
00265 {
00266
00267 if ( KProtocolInfo::supportsListing( _url ) )
00268 return mimeType( QString::fromLatin1("inode/directory") );
00269 else
00270 return defaultMimeTypePtr();
00271 }
00272 }
00273
00274
00275 return defaultMimeTypePtr();
00276 }
00277
00278
00279
00280 KMimeMagicResult* result = KMimeMagic::self()->findFileType( path );
00281
00282
00283 if ( !result || !result->isValid() )
00284 return defaultMimeTypePtr();
00285
00286
00287 return mimeType( result->mimeType() );
00288 }
00289
00290 KMimeType::Ptr KMimeType::findByURL( const KURL& _url, mode_t _mode,
00291 bool _is_local_file, bool _fast_mode,
00292 bool *accurate)
00293 {
00294 KMimeType::Ptr mime = findByURL(_url, _mode, _is_local_file, _fast_mode);
00295 if (accurate) *accurate = !(_fast_mode) || ((mime->patternsAccuracy() == 100) && mime != defaultMimeTypePtr());
00296 return mime;
00297 }
00298
00299 KMimeType::Ptr KMimeType::diagnoseFileName(const QString &fileName, QString &pattern)
00300 {
00301 return KServiceTypeFactory::self()->findFromPattern( fileName, &pattern );
00302 }
00303
00304 KMimeType::Ptr KMimeType::findByPath( const QString& path, mode_t mode, bool fast_mode )
00305 {
00306 KURL u;
00307 u.setPath(path);
00308 return findByURL( u, mode, true, fast_mode );
00309 }
00310
00311 KMimeType::Ptr KMimeType::findByContent( const QByteArray &data, int *accuracy )
00312 {
00313 KMimeMagicResult *result = KMimeMagic::self()->findBufferType(data);
00314 QString type = (result && result->isValid())?
00315 result->mimeType() : defaultMimeType();
00316 if (accuracy)
00317 *accuracy = result->accuracy();
00318 return mimeType( result->mimeType() );
00319 }
00320
00321 KMimeType::Ptr KMimeType::findByFileContent( const QString &fileName, int *accuracy )
00322 {
00323 KMimeMagicResult *result = KMimeMagic::self()->findFileType(fileName);
00324 QString type = (result && result->isValid())?
00325 result->mimeType() : defaultMimeType();
00326 if (accuracy)
00327 *accuracy = result->accuracy();
00328 return mimeType( result->mimeType() );
00329 }
00330
00331 #define GZIP_MAGIC1 0x1f
00332 #define GZIP_MAGIC2 0x8b
00333
00334 KMimeType::Format KMimeType::findFormatByFileContent( const QString &fileName )
00335 {
00336 KMimeType::Format result;
00337 result.compression = Format::NoCompression;
00338 KMimeType::Ptr mime = findByPath(fileName);
00339 if (mime->name() == "application/octet-stream")
00340 mime = findByFileContent(fileName);
00341
00342 result.text = mime->name().startsWith("text/");
00343 QVariant v = mime->property("X-KDE-text");
00344 if (v.isValid())
00345 result.text = v.toBool();
00346
00347 if (mime->name().startsWith("inode/"))
00348 return result;
00349
00350 QFile f(fileName);
00351 if (f.open(IO_ReadOnly))
00352 {
00353 unsigned char buf[10+1];
00354 int l = f.readBlock((char *)buf, 10);
00355 if ((l > 2) && (buf[0] == GZIP_MAGIC1) && (buf[1] == GZIP_MAGIC2))
00356 result.compression = Format::GZipCompression;
00357 }
00358 return result;
00359 }
00360
00361 KMimeType::KMimeType( const QString & _fullpath, const QString& _type, const QString& _icon,
00362 const QString& _comment, const QStringList& _patterns )
00363 : KServiceType( _fullpath, _type, _icon, _comment )
00364 {
00365 m_lstPatterns = _patterns;
00366 }
00367
00368 KMimeType::KMimeType( const QString & _fullpath ) : KServiceType( _fullpath )
00369 {
00370 KDesktopFile _cfg( _fullpath, true );
00371 init ( &_cfg );
00372
00373 if ( !isValid() )
00374 kdWarning(7009) << "mimetype not valid '" << m_strName << "' (missing entry in the file ?)" << endl;
00375 }
00376
00377 KMimeType::KMimeType( KDesktopFile *config ) : KServiceType( config )
00378 {
00379 init( config );
00380
00381 if ( !isValid() )
00382 kdWarning(7009) << "mimetype not valid '" << m_strName << "' (missing entry in the file ?)" << endl;
00383 }
00384
00385 void KMimeType::init( KDesktopFile * config )
00386 {
00387 config->setDesktopGroup();
00388 m_lstPatterns = config->readListEntry( "Patterns", ';' );
00389
00390
00391 QString XKDEAutoEmbed = QString::fromLatin1("X-KDE-AutoEmbed");
00392 if ( config->hasKey( XKDEAutoEmbed ) )
00393 m_mapProps.insert( XKDEAutoEmbed, QVariant( config->readBoolEntry( XKDEAutoEmbed ), 0 ) );
00394
00395 QString XKDEText = QString::fromLatin1("X-KDE-text");
00396 if ( config->hasKey( XKDEText ) )
00397 m_mapProps.insert( XKDEText, config->readBoolEntry( XKDEText ) );
00398
00399 QString XKDEIsAlso = QString::fromLatin1("X-KDE-IsAlso");
00400 if ( config->hasKey( XKDEIsAlso ) )
00401 m_mapProps.insert( XKDEIsAlso, config->readEntry( XKDEIsAlso ) );
00402
00403 QString XKDEPatternsAccuracy = QString::fromLatin1("X-KDE-PatternsAccuracy");
00404 if ( config->hasKey( XKDEPatternsAccuracy ) )
00405 m_mapProps.insert( XKDEPatternsAccuracy, config->readEntry( XKDEPatternsAccuracy ) );
00406
00407 }
00408
00409 KMimeType::KMimeType( QDataStream& _str, int offset ) : KServiceType( _str, offset )
00410 {
00411 loadInternal( _str );
00412 }
00413
00414 void KMimeType::load( QDataStream& _str )
00415 {
00416 KServiceType::load( _str );
00417 loadInternal( _str );
00418 }
00419
00420 void KMimeType::loadInternal( QDataStream& _str )
00421 {
00422
00423 _str >> m_lstPatterns;
00424 }
00425
00426 void KMimeType::save( QDataStream& _str )
00427 {
00428 KServiceType::save( _str );
00429
00430
00431 _str << m_lstPatterns;
00432 }
00433
00434 QVariant KMimeType::property( const QString& _name ) const
00435 {
00436 if ( _name == "Patterns" )
00437 return QVariant( m_lstPatterns );
00438
00439 return KServiceType::property( _name );
00440 }
00441
00442 QStringList KMimeType::propertyNames() const
00443 {
00444 QStringList res = KServiceType::propertyNames();
00445 res.append( "Patterns" );
00446
00447 return res;
00448 }
00449
00450 KMimeType::~KMimeType()
00451 {
00452 }
00453
00454 QPixmap KMimeType::pixmap( KIcon::Group _group, int _force_size, int _state,
00455 QString * _path ) const
00456 {
00457 KIconLoader *iconLoader=KGlobal::iconLoader();
00458 QString iconName=icon( QString::null, false );
00459 if (!iconLoader->extraDesktopThemesAdded())
00460 {
00461 QPixmap pixmap=iconLoader->loadIcon( iconName, _group, _force_size, _state, _path, true );
00462 if (!pixmap.isNull() ) return pixmap;
00463
00464 iconLoader->addExtraDesktopThemes();
00465 }
00466
00467 return iconLoader->loadIcon( iconName , _group, _force_size, _state, _path, false );
00468 }
00469
00470 QPixmap KMimeType::pixmap( const KURL& _url, KIcon::Group _group, int _force_size,
00471 int _state, QString * _path ) const
00472 {
00473 KIconLoader *iconLoader=KGlobal::iconLoader();
00474 QString iconName=icon( _url, _url.isLocalFile() );
00475 if (!iconLoader->extraDesktopThemesAdded())
00476 {
00477 QPixmap pixmap=iconLoader->loadIcon( iconName, _group, _force_size, _state, _path, true );
00478 if (!pixmap.isNull() ) return pixmap;
00479
00480 iconLoader->addExtraDesktopThemes();
00481 }
00482
00483 return iconLoader->loadIcon( iconName , _group, _force_size, _state, _path, false );
00484 }
00485
00486 QPixmap KMimeType::pixmapForURL( const KURL & _url, mode_t _mode, KIcon::Group _group,
00487 int _force_size, int _state, QString * _path )
00488 {
00489 KIconLoader *iconLoader=KGlobal::iconLoader();
00490 QString iconName = iconForURL( _url, _mode );
00491
00492 if (!iconLoader->extraDesktopThemesAdded())
00493 {
00494 QPixmap pixmap=iconLoader->loadIcon( iconName, _group, _force_size, _state, _path, true );
00495 if (!pixmap.isNull() ) return pixmap;
00496
00497 iconLoader->addExtraDesktopThemes();
00498 }
00499
00500 return iconLoader->loadIcon( iconName , _group, _force_size, _state, _path, false );
00501
00502 }
00503
00504 QString KMimeType::iconForURL( const KURL & _url, mode_t _mode )
00505 {
00506 KMimeType::Ptr mt = findByURL( _url, _mode, _url.isLocalFile(),
00507 false );
00508 static const QString& unknown = KGlobal::staticQString("unknown");
00509 QString i( mt->icon( _url, _url.isLocalFile() ));
00510
00511
00512 if ( i == unknown || i.isEmpty() || mt == defaultMimeTypePtr()) {
00513 i = favIconForURL( _url );
00514
00515 if ( i.isEmpty() )
00516 i = KProtocolInfo::icon( _url.protocol() );
00517 }
00518 return i;
00519 }
00520
00521 QString KMimeType::favIconForURL( const KURL& url )
00522 {
00523
00524
00525 static bool useFavIcons = true;
00526 static bool check = true;
00527 if ( check ) {
00528 check = false;
00529 KConfig *config = KGlobal::config();
00530 KConfigGroupSaver cs( config, "HTML Settings" );
00531 useFavIcons = config->readBoolEntry( "EnableFavicon", true );
00532 }
00533
00534 if ( url.isLocalFile() || !url.protocol().startsWith("http")
00535 || !useFavIcons )
00536 return QString::null;
00537
00538 DCOPRef kded( "kded", "favicons" );
00539 DCOPReply result = kded.call( "iconForURL(KURL)", url );
00540 if ( result.isValid() )
00541 return result;
00542
00543 return QString::null;
00544 }
00545
00546 QString KMimeType::parentMimeType() const
00547 {
00548 QVariant v = property("X-KDE-IsAlso");
00549 return v.toString();
00550 }
00551
00552 bool KMimeType::is( const QString& mimeTypeName ) const
00553 {
00554 if ( name() == mimeTypeName )
00555 return true;
00556 QString st = parentMimeType();
00557
00558 while ( !st.isEmpty() )
00559 {
00560
00561 KMimeType::Ptr ptr = KMimeType::mimeType( st );
00562 if (!ptr) return false;
00563 if ( ptr->name() == mimeTypeName )
00564 return true;
00565 st = ptr->parentMimeType();
00566 }
00567 return false;
00568 }
00569
00570 int KMimeType::patternsAccuracy() const {
00571 QVariant v = property("X-KDE-PatternsAccuracy");
00572 if (!v.isValid()) return 100;
00573 else
00574 return v.toInt();
00575 }
00576
00577
00578
00579
00580
00581
00582
00583
00584 QString KFolderType::icon( const QString& _url, bool _is_local ) const
00585 {
00586 if ( !_is_local || _url.isEmpty() )
00587 return KMimeType::icon( _url, _is_local );
00588
00589 return KFolderType::icon( KURL(_url), _is_local );
00590 }
00591
00592 QString KFolderType::icon( const KURL& _url, bool _is_local ) const
00593 {
00594 if ( !_is_local )
00595 return KMimeType::icon( _url, _is_local );
00596
00597 KURL u( _url );
00598 u.addPath( ".directory" );
00599
00600 QString icon;
00601
00602
00603 if ( KStandardDirs::exists( u.path() ) )
00604 {
00605 KSimpleConfig cfg( u.path(), true );
00606 cfg.setDesktopGroup();
00607 icon = cfg.readEntry( "Icon" );
00608 QString empty_icon = cfg.readEntry( "EmptyIcon" );
00609
00610 if ( !empty_icon.isEmpty() )
00611 {
00612 bool isempty = false;
00613 DIR *dp = 0L;
00614 struct dirent *ep;
00615 dp = opendir( QFile::encodeName(_url.path()) );
00616 if ( dp )
00617 {
00618 QValueList<QCString> entries;
00619
00620 ep=readdir( dp ); if ( ep ) entries.append( ep->d_name );
00621 ep=readdir( dp ); if ( ep ) entries.append( ep->d_name );
00622 if ( (ep=readdir( dp )) == 0L )
00623 isempty = true;
00624 else {
00625 entries.append( ep->d_name );
00626 if ( readdir( dp ) == 0 ) {
00627
00628 isempty = entries.find( "." ) != entries.end() &&
00629 entries.find( ".." ) != entries.end() &&
00630 entries.find( ".directory" ) != entries.end();
00631 }
00632 }
00633 if (!isempty && !strcmp(ep->d_name, ".directory"))
00634 isempty = (readdir(dp) == 0L);
00635 closedir( dp );
00636 }
00637
00638 if ( isempty )
00639 return empty_icon;
00640 }
00641 }
00642
00643 if ( icon.isEmpty() )
00644 return KMimeType::icon( _url, _is_local );
00645
00646 if ( icon.startsWith( "./" ) ) {
00647
00648
00649 KURL v( _url );
00650 v.addPath( icon.mid( 2 ) );
00651 icon = v.path();
00652 }
00653
00654 return icon;
00655 }
00656
00657 QString KFolderType::comment( const QString& _url, bool _is_local ) const
00658 {
00659 if ( !_is_local || _url.isEmpty() )
00660 return KMimeType::comment( _url, _is_local );
00661
00662 return KFolderType::comment( KURL(_url), _is_local );
00663 }
00664
00665 QString KFolderType::comment( const KURL& _url, bool _is_local ) const
00666 {
00667 if ( !_is_local )
00668 return KMimeType::comment( _url, _is_local );
00669
00670 KURL u( _url );
00671 u.addPath( ".directory" );
00672
00673 KSimpleConfig cfg( u.path(), true );
00674 cfg.setDesktopGroup();
00675 QString comment = cfg.readEntry( "Comment" );
00676 if ( comment.isEmpty() )
00677 return KMimeType::comment( _url, _is_local );
00678
00679 return comment;
00680 }
00681
00682
00683
00684
00685
00686
00687
00688 QString KDEDesktopMimeType::icon( const QString& _url, bool _is_local ) const
00689 {
00690 if ( !_is_local || _url.isEmpty() )
00691 return KMimeType::icon( _url, _is_local );
00692
00693 KURL u( _url );
00694 return icon( u, _is_local );
00695 }
00696
00697 QString KDEDesktopMimeType::icon( const KURL& _url, bool _is_local ) const
00698 {
00699 if ( !_is_local )
00700 return KMimeType::icon( _url, _is_local );
00701
00702 KSimpleConfig cfg( _url.path(), true );
00703 cfg.setDesktopGroup();
00704 QString icon = cfg.readEntry( "Icon" );
00705 QString type = cfg.readEntry( "Type" );
00706
00707 if ( type == "FSDevice" || type == "FSDev")
00708
00709 {
00710 QString unmount_icon = cfg.readEntry( "UnmountIcon" );
00711 QString dev = cfg.readEntry( "Dev" );
00712 if ( !icon.isEmpty() && !unmount_icon.isEmpty() && !dev.isEmpty() )
00713 {
00714 QString mp = KIO::findDeviceMountPoint( dev );
00715
00716 if ( mp.isNull() )
00717 return unmount_icon;
00718 }
00719 } else if ( type == "Link" ) {
00720 const QString emptyIcon = cfg.readEntry( "EmptyIcon" );
00721 if ( !emptyIcon.isEmpty() ) {
00722 const QString u = cfg.readPathEntry( "URL" );
00723 const KURL url( u );
00724 if ( url.protocol() == "trash" ) {
00725
00726
00727 KSimpleConfig trashConfig( "trashrc", true );
00728 trashConfig.setGroup( "Status" );
00729 if ( trashConfig.readBoolEntry( "Empty", true ) ) {
00730 return emptyIcon;
00731 }
00732 }
00733 }
00734 }
00735
00736 if ( icon.isEmpty() )
00737 return KMimeType::icon( _url, _is_local );
00738
00739 return icon;
00740 }
00741
00742 QPixmap KDEDesktopMimeType::pixmap( const KURL& _url, KIcon::Group _group, int _force_size,
00743 int _state, QString * _path ) const
00744 {
00745 QString _icon = icon( _url, _url.isLocalFile() );
00746 QPixmap pix = KGlobal::iconLoader()->loadIcon( _icon, _group,
00747 _force_size, _state, _path, false );
00748 if ( pix.isNull() )
00749 pix = KGlobal::iconLoader()->loadIcon( "unknown", _group,
00750 _force_size, _state, _path, false );
00751 return pix;
00752 }
00753
00754 QString KDEDesktopMimeType::comment( const QString& _url, bool _is_local ) const
00755 {
00756 if ( !_is_local || _url.isEmpty() )
00757 return KMimeType::comment( _url, _is_local );
00758
00759 KURL u( _url );
00760 return comment( u, _is_local );
00761 }
00762
00763 QString KDEDesktopMimeType::comment( const KURL& _url, bool _is_local ) const
00764 {
00765 if ( !_is_local )
00766 return KMimeType::comment( _url, _is_local );
00767
00768 KSimpleConfig cfg( _url.path(), true );
00769 cfg.setDesktopGroup();
00770 QString comment = cfg.readEntry( "Comment" );
00771 if ( comment.isEmpty() )
00772 return KMimeType::comment( _url, _is_local );
00773
00774 return comment;
00775 }
00776
00777 pid_t KDEDesktopMimeType::run( const KURL& u, bool _is_local )
00778 {
00779
00780
00781 if ( !_is_local )
00782 return 0;
00783
00784 KSimpleConfig cfg( u.path(), true );
00785 cfg.setDesktopGroup();
00786 QString type = cfg.readEntry( "Type" );
00787 if ( type.isEmpty() )
00788 {
00789 QString tmp = i18n("The desktop entry file %1 "
00790 "has no Type=... entry.").arg(u.path() );
00791 KMessageBoxWrapper::error( 0, tmp);
00792 return 0;
00793 }
00794
00795
00796
00797 if ( type == "FSDevice" )
00798 return runFSDevice( u, cfg );
00799 else if ( type == "Application" )
00800 return runApplication( u, u.path() );
00801 else if ( type == "Link" )
00802 {
00803 cfg.setDollarExpansion( true );
00804 return runLink( u, cfg );
00805 }
00806 else if ( type == "MimeType" )
00807 return runMimeType( u, cfg );
00808
00809
00810 QString tmp = i18n("The desktop entry of type\n%1\nis unknown.").arg( type );
00811 KMessageBoxWrapper::error( 0, tmp);
00812
00813 return 0;
00814 }
00815
00816 pid_t KDEDesktopMimeType::runFSDevice( const KURL& _url, const KSimpleConfig &cfg )
00817 {
00818 pid_t retval = 0;
00819
00820 QString dev = cfg.readEntry( "Dev" );
00821
00822 if ( dev.isEmpty() )
00823 {
00824 QString tmp = i18n("The desktop entry file\n%1\nis of type FSDevice but has no Dev=... entry.").arg( _url.path() );
00825 KMessageBoxWrapper::error( 0, tmp);
00826 return retval;
00827 }
00828
00829 QString mp = KIO::findDeviceMountPoint( dev );
00830
00831 if ( !mp.isNull() )
00832 {
00833 KURL mpURL;
00834 mpURL.setPath( mp );
00835
00836 retval = KRun::runURL( mpURL, QString::fromLatin1("inode/directory") );
00837 }
00838 else
00839 {
00840 bool ro = cfg.readBoolEntry( "ReadOnly", false );
00841 QString fstype = cfg.readEntry( "FSType" );
00842 if ( fstype == "Default" )
00843 fstype = QString::null;
00844 QString point = cfg.readEntry( "MountPoint" );
00845 #ifndef Q_WS_WIN
00846 (void) new KAutoMount( ro, fstype, dev, point, _url.path() );
00847 #endif
00848 retval = -1;
00849 }
00850
00851 return retval;
00852 }
00853
00854 pid_t KDEDesktopMimeType::runApplication( const KURL& , const QString & _serviceFile )
00855 {
00856 KService s( _serviceFile );
00857 if ( !s.isValid() )
00858
00859 return 0;
00860
00861 KURL::List lst;
00862 return KRun::run( s, lst );
00863 }
00864
00865 pid_t KDEDesktopMimeType::runLink( const KURL& _url, const KSimpleConfig &cfg )
00866 {
00867 QString u = cfg.readPathEntry( "URL" );
00868 if ( u.isEmpty() )
00869 {
00870 QString tmp = i18n("The desktop entry file\n%1\nis of type Link but has no URL=... entry.").arg( _url.prettyURL() );
00871 KMessageBoxWrapper::error( 0, tmp );
00872 return 0;
00873 }
00874
00875 KURL url ( u );
00876 KRun* run = new KRun(url);
00877
00878
00879
00880
00881 QString lastOpenedWidth = cfg.readEntry( "X-KDE-LastOpenedWith" );
00882 if ( !lastOpenedWidth.isEmpty() )
00883 run->setPreferredService( lastOpenedWidth );
00884
00885 return -1;
00886 }
00887
00888 pid_t KDEDesktopMimeType::runMimeType( const KURL& url , const KSimpleConfig & )
00889 {
00890
00891
00892
00893 QStringList args;
00894 args << "openProperties";
00895 args << url.path();
00896
00897 int pid;
00898 if ( !KApplication::kdeinitExec("kfmclient", args, 0, &pid) )
00899 return pid;
00900
00901 KProcess p;
00902 p << "kfmclient" << args;
00903 p.start(KProcess::DontCare);
00904 return p.pid();
00905 }
00906
00907 QValueList<KDEDesktopMimeType::Service> KDEDesktopMimeType::builtinServices( const KURL& _url )
00908 {
00909 QValueList<Service> result;
00910
00911 if ( !_url.isLocalFile() )
00912 return result;
00913
00914 KSimpleConfig cfg( _url.path(), true );
00915 cfg.setDesktopGroup();
00916 QString type = cfg.readEntry( "Type" );
00917
00918 if ( type.isEmpty() )
00919 return result;
00920
00921 if ( type == "FSDevice" )
00922 {
00923 QString dev = cfg.readEntry( "Dev" );
00924 if ( dev.isEmpty() )
00925 {
00926 QString tmp = i18n("The desktop entry file\n%1\nis of type FSDevice but has no Dev=... entry.").arg( _url.path() );
00927 KMessageBoxWrapper::error( 0, tmp);
00928 }
00929 else
00930 {
00931 QString mp = KIO::findDeviceMountPoint( dev );
00932
00933 if ( mp.isEmpty() )
00934 {
00935 Service mount;
00936 mount.m_strName = i18n("Mount");
00937 mount.m_type = ST_MOUNT;
00938 result.append( mount );
00939 }
00940 else
00941 {
00942 Service unmount;
00943 #ifdef HAVE_VOLMGT
00944
00945
00946
00947 unmount.m_strName = i18n("Eject");
00948 #else
00949 unmount.m_strName = i18n("Unmount");
00950 #endif
00951 unmount.m_type = ST_UNMOUNT;
00952 result.append( unmount );
00953 }
00954 }
00955 }
00956
00957 return result;
00958 }
00959
00960 QValueList<KDEDesktopMimeType::Service> KDEDesktopMimeType::userDefinedServices( const QString& path, bool bLocalFiles )
00961 {
00962 KSimpleConfig cfg( path, true );
00963 return userDefinedServices( path, cfg, bLocalFiles );
00964 }
00965
00966 QValueList<KDEDesktopMimeType::Service> KDEDesktopMimeType::userDefinedServices( const QString& path, KConfig& cfg, bool bLocalFiles )
00967 {
00968 QValueList<Service> result;
00969
00970 cfg.setDesktopGroup();
00971
00972 if ( !cfg.hasKey( "Actions" ) )
00973 return result;
00974
00975 if ( cfg.hasKey( "TryExec" ) )
00976 {
00977 QString tryexec = cfg.readPathEntry( "TryExec" );
00978 QString exe = KStandardDirs::findExe( tryexec );
00979 if (exe.isEmpty()) {
00980 return result;
00981 }
00982 }
00983
00984 QStringList keys = cfg.readListEntry( "Actions", ';' );
00985
00986 if ( keys.count() == 0 )
00987 return result;
00988
00989 QStringList::ConstIterator it = keys.begin();
00990 QStringList::ConstIterator end = keys.end();
00991 for ( ; it != end; ++it )
00992 {
00993
00994
00995 QString group = *it;
00996
00997 if (group == "_SEPARATOR_")
00998 {
00999 Service s;
01000 result.append(s);
01001 continue;
01002 }
01003
01004 group.prepend( "Desktop Action " );
01005
01006 bool bInvalidMenu = false;
01007
01008 if ( cfg.hasGroup( group ) )
01009 {
01010 cfg.setGroup( group );
01011
01012 if ( !cfg.hasKey( "Name" ) || !cfg.hasKey( "Exec" ) )
01013 bInvalidMenu = true;
01014 else
01015 {
01016 QString exec = cfg.readPathEntry( "Exec" );
01017 if ( bLocalFiles || exec.contains("%U") || exec.contains("%u") )
01018 {
01019 Service s;
01020 s.m_strName = cfg.readEntry( "Name" );
01021 s.m_strIcon = cfg.readEntry( "Icon" );
01022 s.m_strExec = exec;
01023 s.m_type = ST_USER_DEFINED;
01024 s.m_display = !cfg.readBoolEntry( "NoDisplay" );
01025 result.append( s );
01026 }
01027 }
01028 }
01029 else
01030 bInvalidMenu = true;
01031
01032 if ( bInvalidMenu )
01033 {
01034 QString tmp = i18n("The desktop entry file\n%1\n has an invalid menu entry\n%2.").arg( path ).arg( *it );
01035 KMessageBoxWrapper::error( 0, tmp );
01036 }
01037 }
01038
01039 return result;
01040 }
01041
01042 void KDEDesktopMimeType::executeService( const QString& _url, KDEDesktopMimeType::Service& _service )
01043 {
01044 KURL u;
01045 u.setPath(_url);
01046 KURL::List lst;
01047 lst.append( u );
01048 executeService( lst, _service );
01049 }
01050
01051 void KDEDesktopMimeType::executeService( const KURL::List& urls, KDEDesktopMimeType::Service& _service )
01052 {
01053
01054
01055 if ( _service.m_type == ST_USER_DEFINED )
01056 {
01057 kdDebug() << "KDEDesktopMimeType::executeService " << _service.m_strName
01058 << " first url's path=" << urls.first().path() << " exec=" << _service.m_strExec << endl;
01059 KRun::run( _service.m_strExec, urls, _service.m_strName, _service.m_strIcon, _service.m_strIcon );
01060
01061 KDirNotify_stub allDirNotify("*", "KDirNotify*");
01062 allDirNotify.FilesChanged( urls );
01063 return;
01064 }
01065 else if ( _service.m_type == ST_MOUNT || _service.m_type == ST_UNMOUNT )
01066 {
01067 Q_ASSERT( urls.count() == 1 );
01068 QString path = urls.first().path();
01069
01070
01071 KSimpleConfig cfg( path, true );
01072 cfg.setDesktopGroup();
01073 QString dev = cfg.readEntry( "Dev" );
01074 if ( dev.isEmpty() )
01075 {
01076 QString tmp = i18n("The desktop entry file\n%1\nis of type FSDevice but has no Dev=... entry.").arg( path );
01077 KMessageBoxWrapper::error( 0, tmp );
01078 return;
01079 }
01080 QString mp = KIO::findDeviceMountPoint( dev );
01081
01082 if ( _service.m_type == ST_MOUNT )
01083 {
01084
01085 if ( !mp.isEmpty() )
01086 {
01087 kdDebug(7009) << "ALREADY Mounted" << endl;
01088 return;
01089 }
01090
01091 bool ro = cfg.readBoolEntry( "ReadOnly", false );
01092 QString fstype = cfg.readEntry( "FSType" );
01093 if ( fstype == "Default" )
01094 fstype = QString::null;
01095 QString point = cfg.readEntry( "MountPoint" );
01096 #ifndef Q_WS_WIN
01097 (void)new KAutoMount( ro, fstype, dev, point, path, false );
01098 #endif
01099 }
01100 else if ( _service.m_type == ST_UNMOUNT )
01101 {
01102
01103 if ( mp.isEmpty() )
01104 return;
01105
01106 #ifndef Q_WS_WIN
01107 (void)new KAutoUnmount( mp, path );
01108 #endif
01109 }
01110 }
01111 else
01112 assert( 0 );
01113 }
01114
01115 const QString & KMimeType::defaultMimeType()
01116 {
01117 static const QString & s_strDefaultMimeType =
01118 KGlobal::staticQString( "application/octet-stream" );
01119 return s_strDefaultMimeType;
01120 }
01121
01122 void KMimeType::virtual_hook( int id, void* data )
01123 { KServiceType::virtual_hook( id, data ); }
01124
01125 void KFolderType::virtual_hook( int id, void* data )
01126 { KMimeType::virtual_hook( id, data ); }
01127
01128 void KDEDesktopMimeType::virtual_hook( int id, void* data )
01129 { KMimeType::virtual_hook( id, data ); }
01130
01131 void KExecMimeType::virtual_hook( int id, void* data )
01132 { KMimeType::virtual_hook( id, data ); }
01133
01134 #include "kmimetyperesolver.moc"
01135