void KMimeTypeTest::testByName()
{
KMimeType::Ptr s0 = KMimeType::mimeType("application/x-zerosize");
QVERIFY(s0);
QCOMPARE(s0->name(), QString::fromLatin1("application/x-zerosize"));
QCOMPARE(s0->comment(), QString::fromLatin1("empty document"));
KMimeType::Ptr s0Again = KMimeType::mimeType("application/x-zerosize");
QCOMPARE(s0Again->name(), s0->name());
QVERIFY(s0Again != s0);
KMimeType::Ptr s1 = KMimeType::mimeType("text/plain");
QVERIFY(s1);
QCOMPARE(s1->name(), QString::fromLatin1("text/plain"));
//qDebug("Comment is %s", qPrintable(s1->comment()) );
KMimeType::Ptr krita = KMimeType::mimeType("application/x-krita");
QVERIFY(krita);
// Test <comment> parsing with application/rdf+xml which has the english comment after the other ones
KMimeType::Ptr rdf = KMimeType::mimeType("application/rdf+xml");
QVERIFY(rdf);
QCOMPARE(rdf->comment(), QString::fromLatin1("RDF file"));
KMimeType::Ptr bzip2 = KMimeType::mimeType("application/x-bzip2");
QVERIFY(bzip2);
QCOMPARE(bzip2->comment(), QString::fromLatin1("Bzip archive"));
KMimeType::Ptr defaultMime = KMimeType::mimeType("application/octet-stream");
QVERIFY(defaultMime);
QVERIFY(defaultMime->isDefault());
}
void URLGrabber::matchingMimeActions(const QString& clipData)
{
KUrl url(clipData);
KConfigGroup cg(KGlobal::config(), "Actions");
if(!cg.readEntry("EnableMagicMimeActions",true)) {
//kDebug() << "skipping mime magic due to configuration";
return;
}
if(!url.isValid()) {
//kDebug() << "skipping mime magic due to invalid url";
return;
}
if(url.isRelative()) { //openinng a relative path will just not work. what path should be used?
//kDebug() << "skipping mime magic due to relative url";
return;
}
if(url.isLocalFile()) {
if ( clipData == "//") {
//kDebug() << "skipping mime magic due to C++ comment //";
return;
}
if(!QFile::exists(url.toLocalFile())) {
//kDebug() << "skipping mime magic due to nonexistent localfile";
return;
}
}
// try to figure out if clipData contains a filename
KMimeType::Ptr mimetype = KMimeType::findByUrl( url, 0,
false,
true /*fast mode*/ );
// let's see if we found some reasonable mimetype.
// If we do we'll populate menu with actions for apps
// that can handle that mimetype
// first: if clipboard contents starts with http, let's assume it's "text/html".
// That is even if we've url like "http://www.kde.org/somescript.pl", we'll
// still treat that as html page, because determining a mimetype using kio
// might take a long time, and i want this function to be quick!
if ( ( clipData.startsWith( QLatin1String("http://") ) || clipData.startsWith( QLatin1String("https://") ) )
&& mimetype->name() != "text/html" )
{
// use a fake path to create a mimetype that corresponds to "text/html"
mimetype = KMimeType::findByPath( "/tmp/klipper.html", 0, true /*fast mode*/ );
}
if ( !mimetype->isDefault() ) {
ClipAction* action = new ClipAction( QString(), mimetype->comment() );
KService::List lst = KMimeTypeTrader::self()->query( mimetype->name(), "Application" );
foreach( const KService::Ptr &service, lst ) {
QHash<QChar,QString> map;
map.insert( 'i', "--icon " + service->icon() );
map.insert( 'c', service->name() );
QString exec = service->exec();
exec = KMacroExpander::expandMacros( exec, map ).trimmed();
action->addCommand( ClipCommand( exec, service->name(), true, service->icon() ) );
}
void BinaryWidget::setData( const QByteArray &data )
{
delete mMainWidget;
QString mimetype;
KMimeType::Ptr mime = KMimeType::findByContent( data );
if ( mime && !mime->isDefault() )
mimetype = mime->name();
if ( !mimetype.isEmpty() ) {
KParts::ReadOnlyPart *part = KParts::ComponentFactory::createPartInstanceFromQuery<KParts::ReadOnlyPart>( mimetype, QString(), this, this );
if ( part ) {
KTemporaryFile file;
file.setAutoRemove(false);
file.open();
file.write( data );
file.flush();
part->openUrl( KUrl( file.fileName() ) );
mMainWidget = part->widget();
} else {
mMainWidget = new QLabel( i18n( "No part found for visualization of mimetype %1", mimetype ), this );
}
mData = data;
mSaveButton->setEnabled( true );
} else {
mMainWidget = new QLabel( i18n( "Got data of unknown mimetype" ), this );
}
mLayout->addWidget( mMainWidget, 0, 0, 3, 1);
mMainWidget->show();
}
static KMimeType::Ptr fixupMimeType (const QString& mimeType, const QString& fileName)
{
KMimeType::Ptr mime = KMimeType::mimeType(mimeType, KMimeType::ResolveAliases);
if ((!mime || mime->isDefault()) && !fileName.isEmpty()) {
mime = KMimeType::findByUrl(fileName, 0, false, true);
}
return mime;
}
void removeExistingExtensions( QString &extension )
{
QStringList filtered;
const QStringList exts = extension.split( ',' );
for ( QStringList::const_iterator it=exts.constBegin(); it!=exts.constEnd(); ++it ) {
QString ext = (*it).trimmed();
if ( ext == "*" ) // some plugins have that, but we don't want to associate a mimetype with *.*!
continue;
KMimeType::Ptr mime = KMimeType::findByUrl( KUrl("file:///foo."+ext ),
0, true, true );
if( mime->isDefault() ||
mime->comment().startsWith("Netscape") ) {
kDebug() << "accepted";
filtered.append( ext );
}
}
extension = filtered.join( "," );
}
KService::Ptr ArkViewer::getViewer(const KMimeType::Ptr &mimeType)
{
// No point in even trying to find anything for application/octet-stream
if (mimeType->isDefault()) {
return KService::Ptr();
}
// Try to get a read-only kpart for the internal viewer
KService::List offers = KMimeTypeTrader::self()->query(mimeType->name(), QString::fromLatin1("KParts/ReadOnlyPart"));
// If we can't find a kpart, try to get an external application
if (offers.size() == 0) {
offers = KMimeTypeTrader::self()->query(mimeType->name(), QString::fromLatin1("Application"));
}
if (offers.size() > 0) {
return offers.first();
} else {
return KService::Ptr();
}
}
QObject* KWebPluginFactory::create(const QString& _mimeType, const QUrl& url, const QStringList& argumentNames, const QStringList& argumentValues) const
{
// Only attempt to find a KPart for the supported mime types...
QVariantList arguments;
const int count = argumentNames.count();
for (int i = 0; i < count; ++i) {
arguments << QString(argumentNames.at(i) + QL1S("=\"") + argumentValues.at(i) + QL1C('\"'));
}
QString mimeType (_mimeType.trimmed());
// If no mimetype is provided, we do our best to correctly determine it here...
if (mimeType.isEmpty()) {
kDebug(800) << "Looking up missing mimetype for plugin resource:" << url;
const KUrl reqUrl (url);
KMimeType::Ptr ptr = KMimeType::findByUrl(reqUrl, 0, reqUrl.isLocalFile());
if (ptr->isDefault())
mimeType = ptr->name();
// Disregard inode/* mime-types...
if (mimeType.startsWith(QLatin1String("inode/"), Qt::CaseInsensitive))
mimeType.clear();
kDebug(800) << "Updated mimetype to" << mimeType;
}
KParts::ReadOnlyPart* part = 0;
// Defer handling of flash content to QtWebKit's builtin viewer.
// If you want to use/test KDE's nspluginviewer, comment out the
// if statement below.
if (!mimeType.isEmpty() && !excludedMimeType(mimeType))
part = KMimeTypeTrader::createPartInstanceFromQuery<KParts::ReadOnlyPart>(mimeType, 0, parent(), QString(), arguments);
kDebug(800) << "Asked for" << mimeType << "plugin, got" << part;
if (part) {
QMap<QString, QString> metaData = part->arguments().metaData();
QString urlStr = url.toString(QUrl::RemovePath | QUrl::RemoveQuery | QUrl::RemoveFragment);
metaData.insert("PropagateHttpHeader", "true");
metaData.insert("referrer", urlStr);
metaData.insert("cross-domain", urlStr);
metaData.insert("main_frame_request", "TRUE");
metaData.insert("ssl_activate_warnings", "TRUE");
KWebPage *page = qobject_cast<KWebPage *>(parent());
if (page) {
const QString scheme = page->mainFrame()->url().scheme();
if (page && (QString::compare(scheme, QL1S("https"), Qt::CaseInsensitive) == 0 ||
QString::compare(scheme, QL1S("webdavs"), Qt::CaseInsensitive) == 0))
metaData.insert("ssl_was_in_use", "TRUE");
else
metaData.insert("ssl_was_in_use", "FALSE");
}
KParts::OpenUrlArguments openUrlArgs = part->arguments();
openUrlArgs.metaData() = metaData;
openUrlArgs.setMimeType(mimeType);
part->setArguments(openUrlArgs);
part->openUrl(url);
return part->widget();
}
return 0;
}
void ArkViewer::view(const QString& fileName, QWidget *parent)
{
KMimeType::Ptr mimeType = KMimeType::findByPath(fileName);
kDebug() << "MIME type" << mimeType->name();
KService::Ptr viewer = ArkViewer::getViewer(mimeType);
const bool needsExternalViewer = (!viewer.isNull() &&
!viewer->hasServiceType(QLatin1String("KParts/ReadOnlyPart")));
if (needsExternalViewer) {
// We have already resolved the MIME type and the service above.
// So there is no point in using KRun::runUrl() which would need
// to do the same again.
const KUrl::List fileUrlList = KUrl(fileName);
// The last argument (tempFiles) set to true means that the temporary
// file will be removed when the viewer application exits.
KRun::run(*viewer, fileUrlList, parent, true);
return;
}
bool viewInInternalViewer = true;
if (viewer.isNull()) {
// No internal viewer available for the file. Ask the user if it
// should be previewed as text/plain.
int response;
if (!mimeType->isDefault()) {
// File has a defined MIME type, and not the default
// application/octet-stream. So it could be viewable as
// plain text, ask the user.
response = KMessageBox::warningContinueCancel(parent,
i18n("The internal viewer cannot preview this type of file<nl/>(%1).<nl/><nl/>Do you want to try to view it as plain text?", mimeType->name()),
i18nc("@title:window", "Cannot Preview File"),
KGuiItem(i18nc("@action:button", "Preview as Text"), KIcon(QLatin1String("text-plain"))),
KStandardGuiItem::cancel(),
QString(QLatin1String("PreviewAsText_%1")).arg(mimeType->name()));
}
else {
// No defined MIME type, or the default application/octet-stream.
// There is still a possibility that it could be viewable as plain
// text, so ask the user. Not the same as the message/question
// above, because the wording and default are different.
response = KMessageBox::warningContinueCancel(parent,
i18n("The internal viewer cannot preview this unknown type of file.<nl/><nl/>Do you want to try to view it as plain text?"),
i18nc("@title:window", "Cannot Preview File"),
KGuiItem(i18nc("@action:button", "Preview as Text"), KIcon(QLatin1String("text-plain"))),
KStandardGuiItem::cancel(),
QString(),
KMessageBox::Dangerous);
}
if (response == KMessageBox::Cancel) {
viewInInternalViewer = false;
}
else { // set for viewer later
mimeType = KMimeType::mimeType(QLatin1String("text/plain"));
}
}
if (viewInInternalViewer) {
ArkViewer *internalViewer = new ArkViewer(parent, Qt::Window);
if (internalViewer->viewInInternalViewer(fileName, mimeType)) {
internalViewer->show();
// The internal viewer is showing the file, and will
// remove the temporary file in dialogClosed(). So there
// is no more to do here.
return;
}
else {
KMessageBox::sorry(parent, i18n("The internal viewer cannot preview this file."));
delete internalViewer;
}
}
// Only get here if there is no internal viewer available or could be
// used for the file, and no external viewer was opened. Nothing can be
// done with the temporary file, so remove it now.
QFile::remove(fileName);
}