• Skip to content
  • Skip to link menu
KDE 4.2 API Reference
  • KDE API Reference
  • kdelibs
  • Sitemap
  • Contact Us
 

KParts

browserrun.cpp

Go to the documentation of this file.
00001 /* This file is part of the KDE project
00002  *
00003  * Copyright (C) 2002 David Faure <faure@kde.org>
00004  * This library is free software; you can redistribute it and/or
00005  * modify it under the terms of the GNU Library General Public
00006  * License version 2, as published by the Free Software Foundation.
00007  *
00008  * This library is distributed in the hope that it will be useful,
00009  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00010  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00011  * Library General Public License for more details.
00012  *
00013  * You should have received a copy of the GNU Library General Public License
00014  * along with this library; see the file COPYING.LIB.  If not, write to
00015  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
00016  * Boston, MA 02110-1301, USA.
00017  */
00018 
00019 #include "browserrun.h"
00020 #include <kmessagebox.h>
00021 #include <kfiledialog.h>
00022 #include <kio/job.h>
00023 #include <kio/jobuidelegate.h>
00024 #include <kio/scheduler.h>
00025 #include <kio/copyjob.h>
00026 #include <klocale.h>
00027 #include <kshell.h>
00028 #include <kstringhandler.h>
00029 #include <kmimetypetrader.h>
00030 #include <ktemporaryfile.h>
00031 #include <kdebug.h>
00032 #include <kde_file.h>
00033 #include <kstandarddirs.h>
00034 #include <assert.h>
00035 
00036 using namespace KParts;
00037 
00038 class BrowserRun::BrowserRunPrivate
00039 {
00040 public:
00041     bool m_bHideErrorDialog;
00042     bool m_bRemoveReferrer;
00043     bool m_bTrustedSource;
00044     KParts::OpenUrlArguments m_args;
00045     KParts::BrowserArguments m_browserArgs;
00046 
00047     KParts::ReadOnlyPart *m_part; // QGuardedPtr?
00048     QPointer<QWidget> m_window;
00049     QString m_mimeType;
00050     QString m_contentDisposition;
00051 };
00052 
00053 BrowserRun::BrowserRun( const KUrl& url, const KParts::OpenUrlArguments& args,
00054                         const KParts::BrowserArguments& browserArgs,
00055                         KParts::ReadOnlyPart *part, QWidget* window,
00056                         bool removeReferrer, bool trustedSource, bool hideErrorDialog )
00057     : KRun( url, window, 0 /*mode*/, false /*is_local_file known*/, false /* no GUI */ ),
00058       d(new BrowserRunPrivate)
00059 {
00060     d->m_bHideErrorDialog = hideErrorDialog;
00061     d->m_bRemoveReferrer = removeReferrer;
00062     d->m_bTrustedSource = trustedSource;
00063     d->m_args = args;
00064     d->m_browserArgs = browserArgs;
00065     d->m_part = part;
00066     d->m_window = window;
00067 }
00068 
00069 BrowserRun::~BrowserRun()
00070 {
00071   delete d;
00072 }
00073 
00074 KParts::ReadOnlyPart* BrowserRun::part() const
00075 {
00076     return d->m_part;
00077 }
00078 
00079 KUrl BrowserRun::url() const
00080 {
00081     return KRun::url();
00082 }
00083 
00084 void BrowserRun::init()
00085 {
00086   if ( d->m_bHideErrorDialog )
00087   {
00088     // ### KRun doesn't call a virtual method when it finds out that the URL
00089     // is either malformed, or points to a non-existing local file...
00090     // So we need to reimplement some of the checks, to handle d->m_bHideErrorDialog
00091     if ( !KRun::url().isValid() ) {
00092         redirectToError( KIO::ERR_MALFORMED_URL, KRun::url().url() );
00093         return;
00094     }
00095     if ( !isLocalFile() && !hasError() && KRun::url().isLocalFile() )
00096       setIsLocalFile( true );
00097 
00098     if ( isLocalFile() )  {
00099       KDE_struct_stat buff;
00100       if ( KDE_stat( QFile::encodeName(KRun::url().toLocalFile()), &buff ) == -1 )
00101       {
00102         kDebug(1000) << KRun::url().toLocalFile() << "doesn't exist.";
00103         redirectToError( KIO::ERR_DOES_NOT_EXIST, KRun::url().toLocalFile() );
00104         return;
00105       }
00106       setMode( buff.st_mode ); // while we're at it, save it for KRun::init() to use it
00107     }
00108   }
00109   KRun::init();
00110 }
00111 
00112 void BrowserRun::scanFile()
00113 {
00114   kDebug(1000) << KRun::url();
00115 
00116   // Let's check for well-known extensions
00117   // Not when there is a query in the URL, in any case.
00118   // Optimization for http/https, findByURL doesn't trust extensions over http.
00119   if ( KRun::url().query().isEmpty() && !KRun::url().protocol().startsWith("http") )
00120   {
00121     KMimeType::Ptr mime = KMimeType::findByUrl( KRun::url() );
00122     assert( mime );
00123     if ( mime->name() != "application/octet-stream" || isLocalFile() )
00124     {
00125       kDebug(1000) << "MIME TYPE is" << mime->name();
00126       mimeTypeDetermined( mime->name() );
00127       return;
00128     }
00129   }
00130 
00131     QMap<QString, QString>& metaData = d->m_args.metaData();
00132     if ( d->m_part ) {
00133         const QString proto = d->m_part->url().protocol().toLower();
00134 
00135       if (proto == "https" || proto == "webdavs") {
00136             metaData.insert("main_frame_request", "TRUE" );
00137             metaData.insert("ssl_was_in_use", "TRUE" );
00138             metaData.insert("ssl_activate_warnings", "TRUE" );
00139       } else if (proto == "http" || proto == "webdav") {
00140             metaData.insert("ssl_activate_warnings", "TRUE" );
00141             metaData.insert("ssl_was_in_use", "FALSE" );
00142       }
00143 
00144       // Set the PropagateHttpHeader meta-data if it has not already been set...
00145         if (!metaData.contains("PropagateHttpHeader"))
00146             metaData.insert("PropagateHttpHeader", "TRUE");
00147   }
00148 
00149   KIO::TransferJob *job;
00150     if ( d->m_browserArgs.doPost() && KRun::url().protocol().startsWith("http")) {
00151         job = KIO::http_post( KRun::url(), d->m_browserArgs.postData, KIO::HideProgressInfo );
00152         job->addMetaData( "content-type", d->m_browserArgs.contentType() );
00153     } else {
00154         job = KIO::get(KRun::url(),
00155                        d->m_args.reload() ? KIO::Reload : KIO::NoReload,
00156                        KIO::HideProgressInfo);
00157   }
00158 
00159     if ( d->m_bRemoveReferrer )
00160         metaData.remove("referrer");
00161 
00162     job->addMetaData( metaData );
00163     job->ui()->setWindow( d->m_window );
00164   connect( job, SIGNAL( result( KJob *)),
00165            this, SLOT( slotBrowserScanFinished(KJob *)));
00166   connect( job, SIGNAL( mimetype( KIO::Job *, const QString &)),
00167            this, SLOT( slotBrowserMimetype(KIO::Job *, const QString &)));
00168   setJob( job );
00169 }
00170 
00171 void BrowserRun::slotBrowserScanFinished(KJob *job)
00172 {
00173   kDebug(1000) << job->error();
00174   if ( job->error() == KIO::ERR_IS_DIRECTORY )
00175   {
00176       // It is in fact a directory. This happens when HTTP redirects to FTP.
00177       // Due to the "protocol doesn't support listing" code in BrowserRun, we
00178       // assumed it was a file.
00179       kDebug(1000) << "It is in fact a directory!";
00180       // Update our URL in case of a redirection
00181       KRun::setUrl( static_cast<KIO::TransferJob *>(job)->url() );
00182       setJob( 0 );
00183       mimeTypeDetermined( "inode/directory" );
00184   }
00185   else
00186   {
00187       if ( job->error() )
00188           handleError( job );
00189       else
00190           KRun::slotScanFinished(job);
00191   }
00192 }
00193 
00194 void BrowserRun::slotBrowserMimetype( KIO::Job *_job, const QString &type )
00195 {
00196     Q_ASSERT( _job == KRun::job() );
00197     KIO::TransferJob *job = static_cast<KIO::TransferJob *>(KRun::job());
00198     // Update our URL in case of a redirection
00199     //kDebug(1000) << "old URL=" << KRun::url();
00200     //kDebug(1000) << "new URL=" << job->url();
00201     setUrl( job->url() );
00202 
00203     if (job->isErrorPage()) {
00204         d->m_mimeType = type;
00205         handleError(job);
00206         setJob( 0 );
00207     } else {
00208         kDebug(1000) << "found" << type << "for" << KRun::url();
00209 
00210         // Suggested filename given by the server (e.g. HTTP content-disposition)
00211         // When set, we should really be saving instead of embedding
00212         const QString suggestedFileName = job->queryMetaData("content-disposition-filename");
00213         setSuggestedFileName(suggestedFileName); // store it (in KRun)
00214         //kDebug(1000) << "suggestedFileName=" << suggestedFileName;
00215         d->m_contentDisposition = job->queryMetaData("content-disposition-type");
00216 
00217         // Make a copy to avoid a dead reference
00218         QString _type = type;
00219         job->putOnHold();
00220         setJob( 0 );
00221 
00222         mimeTypeDetermined( _type );
00223     }
00224 }
00225 
00226 BrowserRun::NonEmbeddableResult BrowserRun::handleNonEmbeddable( const QString& _mimeType )
00227 {
00228     QString mimeType( _mimeType );
00229     Q_ASSERT( !hasFinished() ); // only come here if the mimetype couldn't be embedded
00230     // Support for saving remote files.
00231     if ( mimeType != "inode/directory" && // dirs can't be saved
00232          !KRun::url().isLocalFile() )
00233     {
00234         if ( isTextExecutable(mimeType) )
00235             mimeType = QLatin1String("text/plain"); // view, don't execute
00236         kDebug(1000) << "ask for saving";
00237         KService::Ptr offer = KMimeTypeTrader::self()->preferredService(mimeType, "Application");
00238         // ... -> ask whether to save
00239         KParts::BrowserRun::AskSaveResult res = askSave( KRun::url(), offer, mimeType, suggestedFileName() );
00240         if ( res == KParts::BrowserRun::Save ) {
00241             save( KRun::url(), suggestedFileName() );
00242             kDebug(1000) << "Save: returning Handled";
00243             setFinished( true );
00244             return Handled;
00245         }
00246         else if ( res == KParts::BrowserRun::Cancel ) {
00247             // saving done or canceled
00248             kDebug(1000) << "Cancel: returning Handled";
00249             setFinished( true );
00250             return Handled;
00251         }
00252         else // "Open" chosen (done by KRun::foundMimeType, called when returning NotHandled)
00253         {
00254             // If we were in a POST, we can't just pass a URL to an external application.
00255             // We must save the data to a tempfile first.
00256             if ( d->m_browserArgs.doPost() )
00257             {
00258                 kDebug(1000) << "request comes from a POST, can't pass a URL to another app, need to save";
00259                 d->m_mimeType = mimeType;
00260                 QString extension;
00261                 QString fileName = suggestedFileName().isEmpty() ? KRun::url().fileName() : suggestedFileName();
00262                 int extensionPos = fileName.lastIndexOf( '.' );
00263                 if ( extensionPos != -1 )
00264                     extension = fileName.mid( extensionPos ); // keep the '.'
00265                 KTemporaryFile tempFile;
00266                 tempFile.setSuffix(extension);
00267                 tempFile.setAutoRemove(false);
00268                 tempFile.open();
00269                 KUrl destURL;
00270                 destURL.setPath( tempFile.fileName() );
00271                 KIO::Job *job = KIO::file_copy( KRun::url(), destURL, 0600, KIO::Overwrite );
00272                 job->ui()->setWindow(d->m_window);
00273                 connect( job, SIGNAL(result(KJob *)),
00274                          this, SLOT(slotCopyToTempFileResult(KJob *)) );
00275                 return Delayed; // We'll continue after the job has finished
00276             }
00277         }
00278     }
00279 
00280     // Check if running is allowed
00281     if ( !d->m_bTrustedSource && // ... and untrusted source...
00282          !allowExecution( mimeType, KRun::url() ) ) // ...and the user said no (for executables etc.)
00283     {
00284         setFinished( true );
00285         return Handled;
00286     }
00287 
00288     KIO::SimpleJob::removeOnHold(); // Kill any slave that was put on hold.
00289     return NotHandled;
00290 }
00291 
00292 //static
00293 bool BrowserRun::allowExecution( const QString &mimeType, const KUrl &url )
00294 {
00295     if ( !KRun::isExecutable( mimeType ) )
00296       return true;
00297 
00298     if ( !url.isLocalFile() ) // Don't permit to execute remote files
00299         return false;
00300 
00301     return ( KMessageBox::warningContinueCancel( 0,
00302                                                  i18n( "Do you really want to execute '%1'?", url.prettyUrl() ),
00303     i18n("Execute File?"), KGuiItem(i18n("Execute")) ) == KMessageBox::Continue );
00304 }
00305 
00306 static QString makeQuestion( const KUrl& url, const QString& mimeType, const QString& suggestedFileName )
00307 {
00308     QString surl = url.prettyUrl();
00309     KMimeType::Ptr mime = KMimeType::mimeType(mimeType, KMimeType::ResolveAliases);
00310     QString comment = mimeType;
00311 
00312     // Test if the mimeType is not recognize as octet-stream.
00313     // If so then keep mime-type as comment
00314     if (mime && mime->name() != KMimeType::defaultMimeType()) {
00315         // The mime-type is known so display the comment instead of mime-type
00316         comment = mime->comment();
00317     }
00318     // The strange order in the i18n() calls below is due to the possibility
00319     // of surl containing a '%'
00320     if ( suggestedFileName.isEmpty() )
00321         return i18n("Open '%2'?\nType: %1", comment, surl);
00322     else
00323         return i18n("Open '%3'?\nName: %2\nType: %1", comment, suggestedFileName, surl);
00324 }
00325 
00326 //static
00327 // TODO should take a QWidget* parent argument
00328 BrowserRun::AskSaveResult BrowserRun::askSave( const KUrl & url, KService::Ptr offer, const QString& mimeType, const QString & suggestedFileName )
00329 {
00330     // SYNC SYNC SYNC SYNC SYNC SYNC SYNC SYNC SYNC SYNC SYNC SYNC SYNC SYNC
00331     // NOTE: Keep this function in sync with kdebase/kcontrol/filetypes/filetypedetails.cpp
00332     //       FileTypeDetails::updateAskSave()
00333 
00334     QString question = makeQuestion( url, mimeType, suggestedFileName );
00335 
00336     // Text used for the open button
00337     QString openText = (offer && !offer->name().isEmpty())
00338                        ? i18n("&Open with '%1'", offer->name())
00339                        : i18n("&Open With...");
00340 
00341     int choice = KMessageBox::questionYesNoCancel(
00342         0, question, url.host(),
00343         KStandardGuiItem::saveAs(), KGuiItem(openText), KStandardGuiItem::cancel(),
00344         QLatin1String("askSave")+ mimeType ); // dontAskAgainName, KEEP IN SYNC!!!
00345 
00346     return choice == KMessageBox::Yes ? Save : ( choice == KMessageBox::No ? Open : Cancel );
00347     // SYNC SYNC SYNC SYNC SYNC SYNC SYNC SYNC SYNC SYNC SYNC SYNC SYNC SYNC
00348 }
00349 
00350 //static
00351 // TODO should take a QWidget* parent argument
00352 BrowserRun::AskSaveResult BrowserRun::askEmbedOrSave( const KUrl & url, const QString& mimeType, const QString & suggestedFileName, int flags )
00353 {
00354     // SYNC SYNC SYNC SYNC SYNC SYNC SYNC SYNC SYNC SYNC SYNC SYNC SYNC SYNC
00355     // NOTE: Keep this function in sync with
00356     // kdebase/apps/konqueror/settings/filetypes/filetypedetails.cpp
00357     //       FileTypeDetails::updateAskSave()
00358 
00359     KMimeType::Ptr mime = KMimeType::mimeType(mimeType, KMimeType::ResolveAliases);
00360     // Don't ask for:
00361     // - html (even new tabs would ask, due to about:blank!)
00362     // - dirs obviously (though not common over HTTP :),
00363     // - images (reasoning: no need to save, most of the time, because fast to see)
00364     // e.g. postscript is different, because takes longer to read, so
00365     // it's more likely that the user might want to save it.
00366     // - multipart/* ("server push", see kmultipart)
00367     // - other strange 'internal' mimetypes like print/manager...
00368     // KEEP IN SYNC!!!
00369     if (flags != (int)AttachmentDisposition && mime && (
00370          mime->is( "text/html" ) ||
00371          mime->is( "application/xml" ) ||
00372          mime->is( "inode/directory" ) ||
00373          mimeType.startsWith( "image" ) ||
00374          mime->is( "multipart/x-mixed-replace" ) ||
00375          mime->is( "multipart/replace" ) ||
00376          mimeType.startsWith( "print" ) ) )
00377         return Open;
00378 
00379     QString question = makeQuestion( url, mimeType, suggestedFileName );
00380 
00381     // don't use KStandardGuiItem::open() here which has trailing ellipsis!
00382     int choice = KMessageBox::questionYesNoCancel(
00383         0, question, url.host(),
00384         KStandardGuiItem::saveAs(), KGuiItem( i18n( "&Open" ), "document-open"), KStandardGuiItem::cancel(),
00385         QLatin1String("askEmbedOrSave")+ mimeType ); // dontAskAgainName, KEEP IN SYNC!!!
00386     return choice == KMessageBox::Yes ? Save : ( choice == KMessageBox::No ? Open : Cancel );
00387     // SYNC SYNC SYNC SYNC SYNC SYNC SYNC SYNC SYNC SYNC SYNC SYNC SYNC SYNC
00388 }
00389 
00390 // Default implementation, overridden in KHTMLRun
00391 void BrowserRun::save( const KUrl & url, const QString & suggestedFileName )
00392 {
00393     simpleSave( url, suggestedFileName, d->m_window );
00394 }
00395 
00396 // static
00397 void BrowserRun::simpleSave( const KUrl & url, const QString & suggestedFileName,
00398                              QWidget* window )
00399 {
00400     // DownloadManager <-> konqueror integration
00401     // find if the integration is enabled
00402     // the empty key  means no integration
00403     // only use the downloadmanager for non-local urls
00404     if ( !url.isLocalFile() )
00405     {
00406         KConfigGroup cfg = KSharedConfig::openConfig("konquerorrc", KConfig::NoGlobals)->group("HTML Settings");
00407         QString downloadManger = cfg.readPathEntry("DownloadManager", QString());
00408         if (!downloadManger.isEmpty())
00409         {
00410             // then find the download manager location
00411             kDebug(1000) << "Using: "<<downloadManger <<" as Download Manager";
00412             QString cmd=KStandardDirs::findExe(downloadManger);
00413             if (cmd.isEmpty())
00414             {
00415                 QString errMsg=i18n("The Download Manager (%1) could not be found in your $PATH ", downloadManger);
00416                 QString errMsgEx= i18n("Try to reinstall it  \n\nThe integration with Konqueror will be disabled.");
00417                 KMessageBox::detailedSorry(0,errMsg,errMsgEx);
00418                 cfg.writePathEntry("DownloadManager",QString());
00419                 cfg.sync ();
00420             }
00421             else
00422             {
00423                 // ### suggestedFileName not taken into account. Fix this (and
00424                 // the duplicated code) with shiny new KDownload class for 3.2 (pfeiffer)
00425                 // Until the shiny new class comes about, send the suggestedFileName
00426                 // along with the actual URL to download. (DA)
00427                 cmd += " " + KShell::quoteArg(url.url());
00428                 if ( !suggestedFileName.isEmpty() )
00429                     cmd +=" " + KShell::quoteArg(suggestedFileName);
00430 
00431                 kDebug(1000) << "Calling command" << cmd;
00432                 // slave is already on hold (slotBrowserMimetype())
00433                 KIO::Scheduler::publishSlaveOnHold();
00434                 KRun::runCommand(cmd, window);
00435                 return;
00436             }
00437         }
00438     }
00439 
00440     // no download manager available, let's do it ourself
00441     KFileDialog *dlg = new KFileDialog( QString(), QString() /*all files*/,
00442                                         window);
00443     dlg->setOperationMode( KFileDialog::Saving );
00444     dlg->setCaption(i18n("Save As"));
00445 
00446     dlg->setSelection( suggestedFileName.isEmpty() ? url.fileName() : suggestedFileName );
00447     if ( dlg->exec() )
00448     {
00449         KUrl destURL( dlg->selectedUrl() );
00450         if ( destURL.isValid() )
00451         {
00452             KIO::Job *job = KIO::copy( url, destURL );
00453             job->ui()->setWindow (window);
00454             job->ui()->setAutoErrorHandlingEnabled( true );
00455         }
00456     }
00457     delete dlg;
00458 }
00459 
00460 void BrowserRun::slotStatResult( KJob *job )
00461 {
00462     if ( job->error() ) {
00463         kDebug(1000) << job->errorString();
00464         handleError( job );
00465     } else
00466         KRun::slotStatResult( job );
00467 }
00468 
00469 void BrowserRun::handleError( KJob * job )
00470 {
00471     if ( !job ) { // Shouldn't happen, see docu.
00472         kWarning(1000) << "handleError called with job=0! hideErrorDialog=" << d->m_bHideErrorDialog;
00473         return;
00474     }
00475 
00476     KIO::TransferJob *tjob = qobject_cast<KIO::TransferJob *>(job);
00477     if (tjob && tjob->isErrorPage() && !job->error()) {
00478         // The default handling of error pages is to show them like normal pages
00479         // But this is done here in handleError so that KHTMLRun can reimplement it
00480         tjob->putOnHold();
00481         setJob(0);
00482         if (!d->m_mimeType.isEmpty())
00483             mimeTypeDetermined(d->m_mimeType);
00484         return;
00485     }
00486 
00487     if (d->m_bHideErrorDialog && job->error() != KIO::ERR_NO_CONTENT)
00488     {
00489         redirectToError( job->error(), job->errorText() );
00490         return;
00491     }
00492 
00493     // Reuse code in KRun, to benefit from d->m_showingError etc.
00494     KRun::slotStatResult( job );
00495 }
00496 
00497 void BrowserRun::redirectToError( int error, const QString& errorText )
00498 {
00509     KUrl newURL(QString("error:/?error=%1&errText=%2")
00510                 .arg( error )
00511                 .arg( QString::fromUtf8( QUrl::toPercentEncoding( errorText ) ) ) );
00512     KUrl runURL = KRun::url();
00513     runURL.setPass( QString() ); // don't put the password in the error URL
00514 
00515     KUrl::List lst;
00516     lst << newURL << runURL;
00517     KRun::setUrl( KUrl::join( lst ) );
00518 
00519     setJob( 0 );
00520     mimeTypeDetermined( "text/html" );
00521 }
00522 
00523 void BrowserRun::slotCopyToTempFileResult(KJob *job)
00524 {
00525     if ( job->error() ) {
00526         job->uiDelegate()->showErrorMessage();
00527     } else {
00528         // Same as KRun::foundMimeType but with a different URL
00529         (void) (KRun::runUrl( static_cast<KIO::FileCopyJob *>(job)->destUrl(), d->m_mimeType, d->m_window ));
00530     }
00531     setError( true ); // see above
00532     setFinished( true );
00533     timer().start( 0 );
00534 }
00535 
00536 bool BrowserRun::isTextExecutable( const QString &mimeType )
00537 {
00538     return ( mimeType == "application/x-desktop" ||
00539              mimeType == "application/x-shellscript" );
00540 }
00541 
00542 bool BrowserRun::hideErrorDialog() const
00543 {
00544     return d->m_bHideErrorDialog;
00545 }
00546 
00547 QString BrowserRun::contentDisposition() const {
00548     return d->m_contentDisposition;
00549 }
00550 
00551 KParts::OpenUrlArguments& KParts::BrowserRun::arguments()
00552 {
00553     return d->m_args;
00554 }
00555 
00556 KParts::BrowserArguments& KParts::BrowserRun::browserArguments()
00557 {
00558     return d->m_browserArgs;
00559 }
00560 
00561 #include "browserrun.moc"

KParts

Skip menu "KParts"
  • Main Page
  • Namespace List
  • Class Hierarchy
  • Alphabetical List
  • Class List
  • File List
  • Namespace Members
  • Class Members
  • Related Pages

kdelibs

Skip menu "kdelibs"
  • DNSSD
  • Interfaces
  •   KHexEdit
  •   KMediaPlayer
  •   KSpeech
  •   KTextEditor
  • Kate
  • kconf_update
  • KDE3Support
  •   KUnitTest
  • KDECore
  • KDED
  • KDEsu
  • KDEUI
  • KDocTools
  • KFile
  • KHTML
  • KImgIO
  • KInit
  • kio
  • KIOSlave
  • KJS
  •   KJS-API
  •   WTF
  • kjsembed
  • KNewStuff
  • KParts
  • Kross
  • KUtils
  • Nepomuk
  • Plasma
  • Solid
  • Sonnet
  • ThreadWeaver
Generated for kdelibs by doxygen 1.5.7
This website is maintained by Adriaan de Groot and Allen Winter.
KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal