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