const QString& vfile::vfile_getMime()
{
if (vfile_mimeType.isEmpty()) {
if(vfile_isdir)
vfile_mimeType = "inode/directory";
else if(vfile_isBrokenLink())
vfile_mimeType = "unknown";
else {
QMimeDatabase db;
QMimeType mt = db.mimeTypeForUrl(vfile_getUrl());
vfile_mimeType = mt.isValid() ? mt.name() : "unknown";
if (mt.isValid())
vfile_icon = mt.iconName();
if (vfile_mimeType == "inode/directory") {
vfile_perm[0] = 'd';
vfile_isdir = true;
}
}
if (vfile_isdir && vfile_userDefinedFolderIcons) {
QUrl url = vfile_getUrl();
if (url.isLocalFile()) {
QString file = url.toLocalFile() + "/.directory";
KDesktopFile cfg(file);
QString icon = cfg.readIcon();
if(icon.startsWith(QLatin1String("./"))) // relative path
icon = url.toLocalFile() + '/' + icon;
if (!icon.isEmpty())
vfile_icon = icon;
}
}
}
return vfile_mimeType;
}
QMimeType QMimeDatabasePrivate::mimeTypeForFileNameAndData(const QString &fileName, QIODevice *device, int *accuracyPtr)
{
// First, glob patterns are evaluated. If there is a match with max weight,
// this one is selected and we are done. Otherwise, the file contents are
// evaluated and the match with the highest value (either a magic priority or
// a glob pattern weight) is selected. Matching starts from max level (most
// specific) in both cases, even when there is already a suffix matching candidate.
*accuracyPtr = 0;
// Pass 1) Try to match on the file name
QStringList candidatesByName = mimeTypeForFileName(fileName);
if (candidatesByName.count() == 1) {
*accuracyPtr = 100;
const QMimeType mime = mimeTypeForName(candidatesByName.at(0));
if (mime.isValid())
return mime;
candidatesByName.clear();
}
// Extension is unknown, or matches multiple mimetypes.
// Pass 2) Match on content, if we can read the data
if (device->isOpen()) {
// Read 16K in one go (QIODEVICE_BUFFERSIZE in qiodevice_p.h).
// This is much faster than seeking back and forth into QIODevice.
const QByteArray data = device->peek(16384);
int magicAccuracy = 0;
QMimeType candidateByData(findByData(data, &magicAccuracy));
// Disambiguate conflicting extensions (if magic matching found something)
if (candidateByData.isValid() && magicAccuracy > 0) {
// "for glob_match in glob_matches:"
// "if glob_match is subclass or equal to sniffed_type, use glob_match"
const QString sniffedMime = candidateByData.name();
foreach (const QString &m, candidatesByName) {
if (inherits(m, sniffedMime)) {
// We have magic + pattern pointing to this, so it's a pretty good match
*accuracyPtr = 100;
return mimeTypeForName(m);
}
}
*accuracyPtr = magicAccuracy;
return candidateByData;
}
}
if (candidatesByName.count() > 1) {
*accuracyPtr = 20;
candidatesByName.sort(); // to make it deterministic
const QMimeType mime = mimeTypeForName(candidatesByName.at(0));
if (mime.isValid())
return mime;
}
return mimeTypeForName(defaultMimeType());
}
void tst_QMimeDatabase::mimeTypeForName()
{
QMimeDatabase db;
QMimeType s0 = db.mimeTypeForName(QString::fromLatin1("application/x-zerosize"));
QVERIFY(s0.isValid());
QCOMPARE(s0.name(), QString::fromLatin1("application/x-zerosize"));
QCOMPARE(s0.comment(), QString::fromLatin1("empty document"));
QMimeType s0Again = db.mimeTypeForName(QString::fromLatin1("application/x-zerosize"));
QCOMPARE(s0Again.name(), s0.name());
QMimeType s1 = db.mimeTypeForName(QString::fromLatin1("text/plain"));
QVERIFY(s1.isValid());
QCOMPARE(s1.name(), QString::fromLatin1("text/plain"));
//qDebug("Comment is %s", qPrintable(s1.comment()));
QMimeType krita = db.mimeTypeForName(QString::fromLatin1("application/x-krita"));
QVERIFY(krita.isValid());
// Test <comment> parsing with application/rdf+xml which has the english comment after the other ones
QMimeType rdf = db.mimeTypeForName(QString::fromLatin1("application/rdf+xml"));
QVERIFY(rdf.isValid());
QCOMPARE(rdf.comment(), QString::fromLatin1("RDF file"));
QMimeType bzip2 = db.mimeTypeForName(QString::fromLatin1("application/x-bzip2"));
QVERIFY(bzip2.isValid());
QCOMPARE(bzip2.comment(), QString::fromLatin1("Bzip archive"));
QMimeType defaultMime = db.mimeTypeForName(QString::fromLatin1("application/octet-stream"));
QVERIFY(defaultMime.isValid());
QVERIFY(defaultMime.isDefault());
QMimeType doesNotExist = db.mimeTypeForName(QString::fromLatin1("foobar/x-doesnot-exist"));
QVERIFY(!doesNotExist.isValid());
// TODO move to findByFile
#ifdef Q_OS_LINUX
QString exePath = QStandardPaths::findExecutable(QLatin1String("ls"));
if (exePath.isEmpty())
qWarning() << "ls not found";
else {
const QString executableType = QString::fromLatin1("application/x-executable");
//QTest::newRow("executable") << exePath << executableType;
QCOMPARE(db.mimeTypeForFile(exePath).name(), executableType);
}
#endif
}
EditWithMenu::EditWithMenu(const QUrl& url, QWidget* parent)
: QObject(parent)
, m_menu(0)
, m_url(url)
{
QMimeDatabase db;
QMimeType type = db.mimeTypeForFile(url.path(), QMimeDatabase::MatchExtension);
if ( !type.isValid() )
{
qCDebug(log_cervisia) << "Couldn't find mime type!";
return;
}
m_offers = KMimeTypeTrader::self()->query(type.name());
if( !m_offers.isEmpty() )
{
m_menu = new QMenu(i18n("Edit With"));
KService::List::ConstIterator it = m_offers.constBegin();
for( int i = 0 ; it != m_offers.constEnd(); ++it, ++i )
{
QAction* pAction = m_menu->addAction(QIcon::fromTheme((*it)->icon()), (*it)->name());
pAction->setData(i);
}
connect(m_menu, SIGNAL(triggered(QAction*)),
this, SLOT(actionTriggered(QAction*)));
}
QVariant MessageComposer::data(const QModelIndex &index, int role) const
{
if (!index.isValid() || index.column() != 0 || index.row() < 0 || index.row() >= m_attachments.size())
return QVariant();
switch (role) {
case Qt::DisplayRole:
return m_attachments[index.row()]->caption();
case Qt::ToolTipRole:
return m_attachments[index.row()]->tooltip();
case Qt::DecorationRole:
{
// This is more or less copy-pasted from Gui/AttachmentView.cpp. Unfortunately, sharing the implementation
// is not trivial due to the way how the static libraries are currently built.
QMimeType mimeType = QMimeDatabase().mimeTypeForName(QString::fromUtf8(m_attachments[index.row()]->mimeType()));
if (mimeType.isValid() && !mimeType.isDefault()) {
return QIcon::fromTheme(mimeType.iconName(), UiUtils::loadIcon(QStringLiteral("mail-attachment")));
} else {
return UiUtils::loadIcon(QStringLiteral("mail-attachment"));
}
}
case Imap::Mailbox::RoleAttachmentContentDispositionMode:
return static_cast<int>(m_attachments[index.row()]->contentDispositionMode());
}
return QVariant();
}
bool MimeTypeChecker::isWantedCollection(const Collection &collection, const QString &wantedMimeType)
{
if (wantedMimeType.isEmpty() || !collection.isValid()) {
return false;
}
const QStringList contentMimeTypes = collection.contentMimeTypes();
if (contentMimeTypes.isEmpty()) {
return false;
}
foreach (const QString &mimeType, contentMimeTypes) {
if (mimeType.isEmpty()) {
continue;
}
if (mimeType == wantedMimeType) {
return true;
}
QMimeDatabase db;
const QMimeType mt = db.mimeTypeForName(mimeType);
if (!mt.isValid()) {
continue;
}
if (mt.inherits(wantedMimeType)) {
return true;
}
}
return false;
}
void tst_QMimeDatabase::inheritsPerformance()
{
// Check performance of inherits().
// This benchmark (which started in 2009 in kmimetypetest.cpp) uses 40 mimetypes.
QStringList mimeTypes;
mimeTypes << QLatin1String("image/jpeg") << QLatin1String("image/png") << QLatin1String("image/tiff") << QLatin1String("text/plain") << QLatin1String("text/html");
mimeTypes += mimeTypes;
mimeTypes += mimeTypes;
mimeTypes += mimeTypes;
QCOMPARE(mimeTypes.count(), 40);
QMimeDatabase db;
QMimeType mime = db.mimeTypeForName(QString::fromLatin1("text/x-chdr"));
QVERIFY(mime.isValid());
QBENCHMARK {
QString match;
foreach (const QString &mt, mimeTypes) {
if (mime.inherits(mt)) {
match = mt;
// of course there would normally be a "break" here, but we're testing worse-case
// performance here
}
}
QCOMPARE(match, QString::fromLatin1("text/plain"));
}
// Numbers from 2011, in release mode:
// KDE 4.7 numbers: 0.21 msec / 494,000 ticks / 568,345 instr. loads per iteration
// QMimeBinaryProvider (with Qt 5): 0.16 msec / NA / 416,049 instr. reads per iteration
// QMimeXmlProvider (with Qt 5): 0.062 msec / NA / 172,889 instr. reads per iteration
// (but the startup time is way higher)
// And memory usage is flat at 200K with QMimeBinaryProvider, while it peaks at 6 MB when
// parsing XML, and then keeps being around 4.5 MB for all the in-memory hashes.
}
Vector<String> MIMETypeRegistry::getExtensionsForMIMEType(const String& mimeTypeName)
{
Vector<String> extensions;
QMimeType mimeType = QMimeDatabase().mimeTypeForName(mimeTypeName);
if (mimeType.isValid() && !mimeType.isDefault()) {
Q_FOREACH(const QString& suffix, mimeType.suffixes()) {
extensions.append(suffix);
}
}
static QMimeType mimeType(const QString &name, const QString& fallback)
{
QMimeDatabase mime;
QMimeType type;
if ( !name.isEmpty() )
type = mime.mimeTypeForName(name);
if ( !type.isValid() && fallback != name )
type = mime.mimeTypeForName(fallback);
return type;
}
static QByteArray chooseFormatAndUrl(const QUrl &u, const QMimeData *mimeData,
const QStringList &formats,
const QString &text,
const QString &suggestedFileName,
QWidget *widget,
bool clipboard,
QUrl *newUrl)
{
QMimeDatabase db;
QStringList formatLabels;
for (int i = 0; i < formats.size(); ++i) {
const QString &fmt = formats[i];
QMimeType mime = db.mimeTypeForName(fmt);
if (mime.isValid()) {
formatLabels.append(i18n("%1 (%2)", mime.comment(), fmt));
} else {
formatLabels.append(fmt);
}
}
QString dialogText(text);
if (dialogText.isEmpty()) {
dialogText = i18n("Filename for clipboard content:");
}
//using QString() instead of QString::null didn't compile (with gcc 3.2.3), because the ctor was mistaken as a function declaration, Alex //krazy:exclude=nullstrassign
KIO::PasteDialog dlg(QString::null, dialogText, suggestedFileName, formatLabels, widget, clipboard); //krazy:exclude=nullstrassign
if (dlg.exec() != QDialog::Accepted) {
return QByteArray();
}
if (clipboard && dlg.clipboardChanged()) {
KMessageBox::sorry(widget,
i18n("The clipboard has changed since you used 'paste': "
"the chosen data format is no longer applicable. "
"Please copy again what you wanted to paste."));
return QByteArray();
}
const QString result = dlg.lineEditText();
const QString chosenFormat = formats[ dlg.comboItem() ];
//qDebug() << " result=" << result << " chosenFormat=" << chosenFormat;
*newUrl = u;
newUrl->setPath(newUrl->path() + '/' + result);
// In Qt3, the result of clipboard()->mimeData() only existed until the next
// event loop run (see dlg.exec() above), so we re-fetched it.
// TODO: This should not be necessary with Qt5; remove this conditional
// and test that it still works.
if (clipboard) {
mimeData = QApplication::clipboard()->mimeData();
}
const QByteArray ba = mimeData->data(chosenFormat);
return ba;
}
KoDocumentInfoDlg::KoDocumentInfoDlg(QWidget* parent, KoDocumentInfo* docInfo)
: KPageDialog(parent)
, d(new KoDocumentInfoDlgPrivate)
{
d->info = docInfo;
setWindowTitle(i18n("Document Information"));
// setInitialSize(QSize(500, 500));
setFaceType(KPageDialog::List);
setStandardButtons(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
button(QDialogButtonBox::Ok)->setDefault(true);
d->aboutUi = new Ui::KoDocumentInfoAboutWidget();
QWidget *infodlg = new QWidget();
d->aboutUi->setupUi(infodlg);
d->aboutUi->cbLanguage->addItems(KoGlobal::listOfLanguages());
d->aboutUi->cbLanguage->setCurrentIndex(-1);
KPageWidgetItem *page = new KPageWidgetItem(infodlg, i18n("General"));
page->setHeader(i18n("General"));
// Ugly hack, the mimetype should be a parameter, instead
KoDocumentBase* doc = dynamic_cast< KoDocumentBase* >(d->info->parent());
if (doc) {
QMimeDatabase db;
QMimeType mime = db.mimeTypeForName(doc->mimeType());
if (mime.isValid()) {
page->setIcon(KisIconUtils::loadIcon(mime.iconName()));
}
} else {
// hide all entries not used in pages for KoDocumentInfoPropsPage
d->aboutUi->filePathInfoLabel->setVisible(false);
d->aboutUi->filePathLabel->setVisible(false);
d->aboutUi->filePathSeparatorLine->setVisible(false);
d->aboutUi->lblTypeDesc->setVisible(false);
d->aboutUi->lblType->setVisible(false);
}
addPage(page);
d->pages.append(page);
initAboutTab();
d->authorUi = new Ui::KoDocumentInfoAuthorWidget();
QWidget *authordlg = new QWidget();
d->authorUi->setupUi(authordlg);
page = new KPageWidgetItem(authordlg, i18n("Author"));
page->setHeader(i18n("Last saved by"));
page->setIcon(koIcon("user-identity"));
addPage(page);
d->pages.append(page);
initAuthorTab();
}
KIso::KIso(const QString& filename, const QString & _mimetype)
: KArchive(0L)
{
KISOFUNC;
KISODEBUG("Starting KIso: " << filename << " - type: " << _mimetype);
m_startsec = -1;
m_filename = filename;
d = new KIsoPrivate;
QString mimetype(_mimetype);
bool forced = true;
if (mimetype.isEmpty()) {
QMimeDatabase db;
QMimeType mt = db.mimeTypeForFile(filename, QMimeDatabase::MatchContent);
if (mt.isValid())
mimetype = mt.name();
//qDebug() << "KIso::KIso mimetype=" << mimetype << endl;
// Don't move to prepareDevice - the other constructor theoretically allows ANY filter
if (mimetype == "application/x-tgz" || mimetype == "application/x-targz" || // the latter is deprecated but might still be around
mimetype == "application/x-webarchive")
// that's a gzipped tar file, so ask for gzip filter
mimetype = "application/x-gzip";
else if (mimetype == "application/x-tbz") // that's a bzipped2 tar file, so ask for bz2 filter
mimetype = "application/x-bzip2";
else {
// Something else. Check if it's not really gzip though (e.g. for KOffice docs)
QFile file(filename);
if (file.open(QIODevice::ReadOnly)) {
char firstByte;
char secondByte;
char thirdByte;
file.getChar(&firstByte);
file.getChar(&secondByte);
file.getChar(&thirdByte);
if (firstByte == 0037 && secondByte == (char)0213)
mimetype = "application/x-gzip";
else if (firstByte == 'B' && secondByte == 'Z' && thirdByte == 'h')
mimetype = "application/x-bzip2";
else if (firstByte == 'P' && secondByte == 'K' && thirdByte == 3) {
char fourthByte;
file.getChar(&fourthByte);
if (fourthByte == 4)
mimetype = "application/x-zip";
}
}
}
forced = false;
}
prepareDevice(filename, mimetype, forced);
}
QString vfile::vfile_getIcon()
{
if (vfile_icon.isEmpty()) {
QString mime = vfile_getMime();
if (vfile_isBrokenLink())
vfile_icon = "file-broken";
else if (vfile_icon.isEmpty()) {
QMimeDatabase db;
QMimeType mt = db.mimeTypeForName(mime);
vfile_icon = mt.isValid() ? mt.iconName() : "file-broken";
}
}
return vfile_icon;
}
String MIMETypeRegistry::getMIMETypeForPath(const String& path)
{
QMimeType type = QMimeDatabase().mimeTypeForFile(path, QMimeDatabase::MatchExtension);
if (type.isValid() && !type.isDefault())
return type.name();
const ExtensionMap *e = extensionMap;
while (e->extension) {
if (path.endsWith(e->dotExtension))
return e->mimeType;
++e;
}
return defaultMIMEType();
}
KisFilterChooser::KisFilterChooser(QWidget *parent, const QStringList &mimeTypes, const QString &/*nativeFormat*/, const QUrl &url)
: KoDialog(parent),
m_mimeTypes(mimeTypes)
{
setObjectName("kofilterchooser");
setInitialSize(QSize(300, 350));
setButtons(KoDialog::Ok|KoDialog::Cancel);
setDefaultButton(KoDialog::Ok);
setCaption(i18n("Choose Filter"));
setModal(true);
QWidget *page = new QWidget(this);
setMainWidget(page);
QVBoxLayout *layout = new QVBoxLayout(page);
if (url.isValid()) {
KSqueezedTextLabel *l = new KSqueezedTextLabel(url.path(), page);
layout->addWidget(l);
}
m_filterList = new QListWidget(page);
layout->addWidget(m_filterList);
page->setLayout(layout);
Q_ASSERT(!m_mimeTypes.isEmpty());
for (QStringList::ConstIterator it = m_mimeTypes.constBegin();
it != m_mimeTypes.constEnd();
++it) {
QMimeDatabase db;
QMimeType mime = db.mimeTypeForName(*it);
const QString name = mime.isValid() ? mime.comment() : *it;
if (! name.isEmpty()) {
QListWidgetItem *item = new QListWidgetItem(name, m_filterList);
item->setData(32, *it);
}
}
m_filterList->sortItems();
if (m_filterList->currentRow() == -1)
m_filterList->setCurrentRow(0);
m_filterList->setFocus();
connect(m_filterList, SIGNAL(itemDoubleClicked(QListWidgetItem*)), this, SLOT(accept()));
resize(QSize(520, 400));//.expandedTo(minimumSizeHint()));
}
bool StaticSimple::locateStaticFile(Context *c, const QString &relPath)
{
Q_D(const StaticSimple);
for (const QDir &includePath : d->includePaths) {
QString path = includePath.absoluteFilePath(relPath);
QFileInfo fileInfo(path);
if (fileInfo.exists()) {
Response *res = c->res();
const QDateTime currentDateTime = fileInfo.lastModified();
if (currentDateTime == c->req()->headers().ifModifiedSinceDateTime()) {
res->setStatus(Response::NotModified);
return true;
}
QFile *file = new QFile(path);
if (file->open(QFile::ReadOnly)) {
qCDebug(C_STATICSIMPLE) << "Serving" << path;
Headers &headers = res->headers();
// set our open file
res->setBody(file);
QMimeDatabase db;
// use the extension to match to be faster
QMimeType mimeType = db.mimeTypeForFile(path, QMimeDatabase::MatchExtension);
if (mimeType.isValid()) {
headers.setContentType(mimeType.name());
}
headers.setContentLength(file->size());
headers.setLastModified(currentDateTime);
// Tell Firefox & friends its OK to cache, even over SSL
headers.setHeader(QStringLiteral("Cache-Control"), QStringLiteral("public"));
return true;
}
qCWarning(C_STATICSIMPLE) << "Could not serve" << path << file->errorString();
return false;
}
}
qCWarning(C_STATICSIMPLE) << "File not found" << relPath;
return false;
}
//! [5]
QStringList Window::findFiles(const QStringList &files, const QString &text) {
QProgressDialog progressDialog(this);
progressDialog.setCancelButtonText(tr("&Cancel"));
progressDialog.setRange(0, files.size());
progressDialog.setWindowTitle(tr("Find Files"));
//! [5] //! [6]
QMimeDatabase mimeDatabase;
QStringList foundFiles;
for (int i = 0; i < files.size(); ++i) {
progressDialog.setValue(i);
progressDialog.setLabelText(
tr("Searching file number %1 of %n...", 0, files.size()).arg(i));
QCoreApplication::processEvents();
//! [6]
if (progressDialog.wasCanceled()) break;
//! [7]
const QString fileName = files.at(i);
const QMimeType mimeType = mimeDatabase.mimeTypeForFile(fileName);
if (mimeType.isValid() &&
!mimeType.inherits(QStringLiteral("text/plain"))) {
qWarning() << "Not searching binary file "
<< QDir::toNativeSeparators(fileName);
continue;
}
QFile file(fileName);
if (file.open(QIODevice::ReadOnly)) {
QString line;
QTextStream in(&file);
while (!in.atEnd()) {
if (progressDialog.wasCanceled()) break;
line = in.readLine();
if (line.contains(text, Qt::CaseInsensitive)) {
foundFiles << files[i];
break;
}
}
}
}
return foundFiles;
}
void Imagesplit::slotImagesplit()
{
// Taking the title - url from caption function and removing file extension
QStringList strList = ((m_view->document())->caption()).split('.');
QString suffix = strList.at(0);
// Getting all mime types and converting them into names which are displayed at combo box
QStringList listMimeFilter = KisImportExportManager::mimeFilter("application/x-krita", KisImportExportManager::Export);
QStringList filteredMimeTypes;
QStringList listFileType;
foreach(const QString & tempStr, listMimeFilter) {
QMimeDatabase db;
QMimeType type = db.mimeTypeForName(tempStr);
dbgKrita << tempStr << type;
if (type.isValid()) {
listFileType.append(type.comment());
filteredMimeTypes.append(tempStr);
}
}
PluginRegistry()
: mDefaultPlugin(PluginEntry(QStringLiteral("application/octet-stream@QByteArray"), s_defaultItemSerializerPlugin))
, mOverridePlugin(0)
{
const PluginLoader *pl = PluginLoader::self();
if (!pl) {
qWarning() << "Cannot instantiate plugin loader!" << endl;
return;
}
const QStringList names = pl->names();
qDebug() << "ItemSerializerPluginLoader: "
<< "found" << names.size() << "plugins." << endl;
QMap<QString, MimeTypeEntry> map;
QRegExp rx(QStringLiteral("(.+)@(.+)"));
QMimeDatabase mimeDb;
Q_FOREACH (const QString &name, names) {
if (rx.exactMatch(name)) {
const QMimeType mime = mimeDb.mimeTypeForName(rx.cap(1));
if (mime.isValid()) {
const QString mimeType = mime.name();
const QByteArray classType = rx.cap(2).toLatin1();
QMap<QString, MimeTypeEntry>::iterator it = map.find(mimeType);
if (it == map.end()) {
it = map.insert(mimeType, MimeTypeEntry(mimeType));
}
it->add(classType, PluginEntry(name));
}
} else {
qDebug() << "ItemSerializerPluginLoader: "
<< "name" << name << "doesn't look like mimetype@classtype" << endl;
}
}
const QString APPLICATION_OCTETSTREAM = QLatin1String(_APPLICATION_OCTETSTREAM);
QMap<QString, MimeTypeEntry>::iterator it = map.find(APPLICATION_OCTETSTREAM);
if (it == map.end()) {
it = map.insert(APPLICATION_OCTETSTREAM, MimeTypeEntry(APPLICATION_OCTETSTREAM));
}
it->add("QByteArray", mDefaultPlugin);
it->add(LEGACY_NAME, mDefaultPlugin);
const int size = map.size();
allMimeTypes.reserve(size);
std::copy(map.begin(), map.end(), std::back_inserter(allMimeTypes));
}
bool Helper::handleGetFromType()
{
if( !readArguments( 1 ))
return false;
QString type = getArgument();
if( !allArgumentsUsed())
return false;
QMimeType mime = QMimeDatabase().mimeTypeForName(type);
if (mime.isValid()) return writeMimeInfo(mime);
// firefox also asks for protocol handlers using getfromtype
QString app = getAppForProtocol( type );
if( !app.isEmpty())
{
outputLine( type );
outputLine( type ); // TODO probably no way to find a good description
outputLine( app );
return true;
}
return false;
}
QMimeType QMimeDatabasePrivate::findByData(const QByteArray &data, int *accuracyPtr)
{
if (data.isEmpty()) {
*accuracyPtr = 100;
return mimeTypeForName(QLatin1String("application/x-zerosize"));
}
*accuracyPtr = 0;
QMimeType candidate = provider()->findByMagic(data, accuracyPtr);
if (candidate.isValid())
return candidate;
if (isTextFile(data)) {
*accuracyPtr = 5;
return mimeTypeForName(QLatin1String("text/plain"));
}
return mimeTypeForName(defaultMimeType());
}
bool TorrentFile::isMultimedia() const
{
if (filetype == UNKNOWN)
{
QMimeType ptr = QMimeDatabase().mimeTypeForFile(getPath());
if (!ptr.isValid())
{
filetype = NORMAL;
return false;
}
QString name = ptr.name();
if (name.startsWith(QLatin1String("audio")) || name == QLatin1String("application/ogg"))
filetype = AUDIO;
else if (name.startsWith(QLatin1String("video")))
filetype = VIDEO;
else
filetype = NORMAL;
}
return filetype == AUDIO || filetype == VIDEO;
}
bool MimeTypeChecker::isWantedItem(const Item &item, const QString &wantedMimeType)
{
if (wantedMimeType.isEmpty() || !item.isValid()) {
return false;
}
const QString mimeType = item.mimeType();
if (mimeType.isEmpty()) {
return false;
}
if (mimeType == wantedMimeType) {
return true;
}
QMimeDatabase db;
const QMimeType mt = db.mimeTypeForName(mimeType);
if (!mt.isValid()) {
return false;
}
return mt.inherits(wantedMimeType);
}
bool Helper::handleOpen()
{
if( !readArguments( 1 ))
return false;
QUrl url = QUrl::fromUserInput(getArgument());
QString mime;
if( isArgument( "MIMETYPE" ))
mime = getArgument();
if( !allArgumentsUsed())
return false;
//KApplication::updateUserTimestamp( 0 ); // TODO
// try to handle the case when the server has broken mimetypes and e.g. claims something is application/octet-stream
QMimeType mimeType = QMimeDatabase().mimeTypeForName(mime);
if (!mime.isEmpty() && mimeType.isValid() && KMimeTypeTrader::self()->preferredService(mimeType.name()))
return KRun::runUrl( url, mime, NULL ); // TODO parent
else
{
(void) new KRun( url, NULL ); // TODO parent
// QObject::connect( run, SIGNAL( finished()), &app, SLOT( openDone()));
// QObject::connect( run, SIGNAL( error()), &app, SLOT( openDone()));
return true; // TODO check for errors?
}
}
QString KisImportExportManager::importDocument(const QString& url,
const QString& documentMimeType,
KisImportExportFilter::ConversionStatus& status)
{
// Find the mime type for the file to be imported.
QString typeName(documentMimeType);
QUrl u(url);
QMimeType t;
if (documentMimeType.isEmpty()) {
QMimeDatabase db;
db.mimeTypeForFile(u.path(), QMimeDatabase::MatchExtension);
if (t.isValid())
typeName = t.name();
}
m_graph.setSourceMimeType(typeName.toLatin1()); // .latin1() is okay here (Werner)
if (!m_graph.isValid()) {
bool userCancelled = false;
warnFile << "Can't open " << typeName << ", trying filter chooser";
if (m_document) {
if (!m_document->isAutoErrorHandlingEnabled()) {
status = KisImportExportFilter::BadConversionGraph;
return QString();
}
QByteArray nativeFormat = m_document->nativeFormatMimeType();
QApplication::setOverrideCursor(Qt::ArrowCursor);
KisFilterChooser chooser(0,
KisImportExportManager::mimeFilter(nativeFormat, KisImportExportManager::Import,
m_document->extraNativeMimeTypes()), nativeFormat, u);
if (chooser.exec()) {
QByteArray f = chooser.filterSelected().toLatin1();
if (f == nativeFormat) {
status = KisImportExportFilter::OK;
QApplication::restoreOverrideCursor();
return url;
}
m_graph.setSourceMimeType(f);
} else
userCancelled = true;
QApplication::restoreOverrideCursor();
}
if (!m_graph.isValid()) {
errFile << "Couldn't create a valid graph for this source mimetype: "
<< typeName;
importErrorHelper(typeName, userCancelled);
status = KisImportExportFilter::BadConversionGraph;
return QString();
}
}
KisFilterChain::Ptr chain(0);
// Are we owned by a KisDocument?
if (m_document) {
QByteArray mimeType = m_document->nativeFormatMimeType();
QStringList extraMimes = m_document->extraNativeMimeTypes();
int i = 0;
int n = extraMimes.count();
chain = m_graph.chain(this, mimeType);
while (i < n) {
QByteArray extraMime = extraMimes[i].toUtf8();
// TODO check if its the same target mime then continue
KisFilterChain::Ptr newChain(0);
newChain = m_graph.chain(this, extraMime);
if (!chain || (newChain && newChain->weight() < chain->weight()))
chain = newChain;
++i;
}
} else if (!d->importMimeType.isEmpty()) {
chain = m_graph.chain(this, d->importMimeType);
} else {
errFile << "You aren't supposed to use import() from a filter!" << endl;
status = KisImportExportFilter::UsageError;
return QString();
}
if (!chain) {
errFile << "Couldn't create a valid filter chain!" << endl;
importErrorHelper(typeName);
status = KisImportExportFilter::BadConversionGraph;
return QString();
}
// Okay, let's invoke the filters one after the other
m_direction = Import; // vital information!
m_importUrl = url; // We want to load that file
m_exportUrl.clear(); // This is null for sure, as embedded stuff isn't
// allowed to use that method
status = chain->invokeChain();
m_importUrl.clear(); // Reset the import URL
if (status == KisImportExportFilter::OK)
return chain->chainOutput();
return QString();
}
KisImportExportFilter::ConversionStatus KisImportExportManager::exportDocument(const QString& url, QByteArray& mimeType)
{
bool userCancelled = false;
// The import url should already be set correctly (null if we have a KisDocument
// file manager and to the correct URL if we have an embedded manager)
m_direction = Export; // vital information!
m_exportUrl = url;
KisFilterChain::Ptr chain;
if (m_document) {
// We have to pick the right native mimetype as source.
QStringList nativeMimeTypes;
nativeMimeTypes.append(m_document->nativeFormatMimeType());
nativeMimeTypes += m_document->extraNativeMimeTypes();
QStringList::ConstIterator it = nativeMimeTypes.constBegin();
const QStringList::ConstIterator end = nativeMimeTypes.constEnd();
for (; !chain && it != end; ++it) {
m_graph.setSourceMimeType((*it).toLatin1());
if (m_graph.isValid())
chain = m_graph.chain(this, mimeType);
}
} else if (!m_importUrlMimetypeHint.isEmpty()) {
dbgFile << "Using the mimetype hint:" << m_importUrlMimetypeHint;
m_graph.setSourceMimeType(m_importUrlMimetypeHint);
} else {
QUrl u;
u.setPath(m_importUrl);
QMimeDatabase db;
QMimeType t = db.mimeTypeForFile(u.path(), QMimeDatabase::MatchExtension);
if (!t.isValid() || t.isDefault()) {
errFile << "No mimetype found for" << m_importUrl;
return KisImportExportFilter::BadMimeType;
}
m_graph.setSourceMimeType(t.name().toLatin1());
if (!m_graph.isValid()) {
warnFile << "Can't open" << t.name() << ", trying filter chooser";
QApplication::setOverrideCursor(Qt::ArrowCursor);
KisFilterChooser chooser(0, KisImportExportManager::mimeFilter(), QString(), u);
if (chooser.exec())
m_graph.setSourceMimeType(chooser.filterSelected().toLatin1());
else
userCancelled = true;
QApplication::restoreOverrideCursor();
}
}
if (!m_graph.isValid()) {
errFile << "Couldn't create a valid graph for this source mimetype.";
if (!d->batch && !userCancelled) {
QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Could not export file: the export filter is missing."));
}
return KisImportExportFilter::BadConversionGraph;
}
if (!chain) // already set when coming from the m_document case
chain = m_graph.chain(this, mimeType);
if (!chain) {
errFile << "Couldn't create a valid filter chain to " << mimeType << " !" << endl;
if (!d->batch) {
QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Could not export file: the export filter is missing."));
}
return KisImportExportFilter::BadConversionGraph;
}
return chain->invokeChain();
}
// Only called when a filename was given
bool KTar::createDevice(QIODevice::OpenMode mode)
{
if (d->mimetype.isEmpty()) {
// Find out mimetype manually
QMimeDatabase db;
QMimeType mime;
if (mode != QIODevice::WriteOnly && QFile::exists(fileName())) {
// Give priority to file contents: if someone renames a .tar.bz2 to .tar.gz,
// we can still do the right thing here.
QFile f(fileName());
if (f.open(QIODevice::ReadOnly)) {
mime = db.mimeTypeForData(&f);
}
if (!mime.isValid()) {
// Unable to determine mimetype from contents, get it from file name
mime = db.mimeTypeForFile(fileName(), QMimeDatabase::MatchExtension);
}
} else {
mime = db.mimeTypeForFile(fileName(), QMimeDatabase::MatchExtension);
}
//qDebug() << mode << mime->name();
if (mime.inherits(QString::fromLatin1("application/x-compressed-tar")) || mime.inherits(QString::fromLatin1(application_gzip))) {
// gzipped tar file (with possibly invalid file name), ask for gzip filter
d->mimetype = QString::fromLatin1(application_gzip);
} else if (mime.inherits(QString::fromLatin1("application/x-bzip-compressed-tar")) || mime.inherits(QString::fromLatin1(application_bzip))) {
// bzipped2 tar file (with possibly invalid file name), ask for bz2 filter
d->mimetype = QString::fromLatin1(application_bzip);
} else if (mime.inherits(QString::fromLatin1("application/x-lzma-compressed-tar")) || mime.inherits(QString::fromLatin1(application_lzma))) {
// lzma compressed tar file (with possibly invalid file name), ask for xz filter
d->mimetype = QString::fromLatin1(application_lzma);
} else if (mime.inherits(QString::fromLatin1("application/x-xz-compressed-tar")) || mime.inherits(QString::fromLatin1(application_xz))) {
// xz compressed tar file (with possibly invalid name), ask for xz filter
d->mimetype = QString::fromLatin1(application_xz);
}
}
if (d->mimetype == QLatin1String("application/x-tar")) {
return KArchive::createDevice(mode);
} else if (mode == QIODevice::WriteOnly) {
if (!KArchive::createDevice(mode))
return false;
if (!d->mimetype.isEmpty()) {
// Create a compression filter on top of the QSaveFile device that KArchive created.
//qDebug() << "creating KFilterDev for" << d->mimetype;
KCompressionDevice::CompressionType type = KFilterDev::compressionTypeForMimeType(d->mimetype);
KCompressionDevice* compressionDevice = new KCompressionDevice(device(), true, type);
setDevice(compressionDevice);
}
return true;
} else {
// The compression filters are very slow with random access.
// So instead of applying the filter to the device,
// the file is completely extracted instead,
// and we work on the extracted tar file.
// This improves the extraction speed by the tar ioslave dramatically,
// if the archive file contains many files.
// This is because the tar ioslave extracts one file after the other and normally
// has to walk through the decompression filter each time.
// Which is in fact nearly as slow as a complete decompression for each file.
Q_ASSERT(!d->tmpFile);
d->tmpFile = new QTemporaryFile();
d->tmpFile->setFileTemplate(QLatin1String("ktar-XXXXXX.tar"));
d->tmpFile->open();
//qDebug() << "creating tempfile:" << d->tmpFile->fileName();
setDevice(d->tmpFile);
return true;
}
}
int main(int argc, char **argv)
{
KLocalizedString::setApplicationDomain( "koconverter" );
K4AboutData aboutData("calligraconverter", 0, ki18n("CalligraConverter"), CalligraVersionWrapper::versionString().toLatin1(),
ki18n("Calligra Document Converter"),
K4AboutData::License_GPL,
ki18n("(c) 2001-2011 Calligra developers"));
aboutData.addAuthor(ki18n("David Faure"), KLocalizedString(), "*****@*****.**");
aboutData.addAuthor(ki18n("Nicolas Goutte"), KLocalizedString(), "*****@*****.**");
aboutData.addAuthor(ki18n("Dan Leinir Turthra Jensen"), KLocalizedString(), "*****@*****.**");
KCmdLineArgs::init(argc, argv, &aboutData);
KCmdLineOptions options;
options.add("+in", ki18n("Input file"));
options.add("+out", ki18n("Output file"));
options.add("backup", ki18n("Make a backup of the destination file"));
options.add("batch", ki18n("Batch mode: do not show dialogs"));
options.add("interactive", ki18n("Interactive mode: show dialogs (default)"));
options.add("mimetype <mime>", ki18n("Mimetype of the output file"));
// PDF related options.
options.add("print-orientation <name>", ki18n("The print orientation. This could be either Portrait or Landscape."));
options.add("print-papersize <name>", ki18n("The paper size. A4, Legal, Letter, ..."));
options.add("print-margin <size>", ki18n("The size of the paper margin. By default this is 0.2."));
KCmdLineArgs::addCmdLineOptions(options);
KApplication app;
// Get the command line arguments which we have to parse
KCmdLineArgs *args = KCmdLineArgs::parsedArgs();
if (args->count() != 2) {
KCmdLineArgs::usageError(i18n("Two arguments required"));
return 3;
}
const QUrl urlIn = args->url(0);
const QUrl urlOut = args->url(1);
// Are we in batch mode or in interactive mode.
bool batch = args->isSet("batch");
if (args->isSet("interactive")) {
batch = false;
}
if (args->isSet("backup")) {
// Code form koDocument.cc
KIO::UDSEntry entry;
if (KIO::NetAccess::stat(urlOut, entry, 0L)) { // this file exists => backup
kDebug() << "Making backup...";
QUrl backup(urlOut);
backup.setPath(urlOut.path() + '~');
KIO::FileCopyJob *job = KIO::file_copy(urlOut, backup, -1, KIO::Overwrite | KIO::HideProgressInfo);
job->exec();
}
}
QMimeDatabase db;
QMimeType inputMimetype = db.mimeTypeForUrl(urlIn);
if (!inputMimetype.isValid() || inputMimetype.isDefault()) {
kError() << i18n("Mimetype for input file %1 not found!", urlIn.toDisplayString()) << endl;
return 1;
}
QMimeType outputMimetype;
if (args->isSet("mimetype")) {
QString mime = args->getOption("mimetype");
outputMimetype = db.mimeTypeForName(mime);
if (! outputMimetype.isValid()) {
kError() << i18n("Mimetype not found %1", mime) << endl;
return 1;
}
} else {
outputMimetype = db.mimeTypeForUrl(urlOut);
if (!outputMimetype.isValid() || outputMimetype.isDefault()) {
kError() << i18n("Mimetype not found, try using the -mimetype option") << endl;
return 1;
}
}
QApplication::setOverrideCursor(Qt::WaitCursor);
QString outputFormat = outputMimetype.name();
bool ok = false;
if (outputFormat == "application/pdf") {
QString orientation = args->getOption("print-orientation");
QString papersize = args->getOption("print-papersize");
QString margin = args->getOption("print-margin");
ok = convertPdf(urlIn, inputMimetype.name(), urlOut, outputFormat, orientation, papersize, margin);
} else {
ok = convert(urlIn, inputMimetype.name(), urlOut, outputFormat, batch);
}
QTimer::singleShot(0, &app, SLOT(quit()));
app.exec();
QApplication::restoreOverrideCursor();
if (!ok) {
kError() << i18n("*** The conversion failed! ***") << endl;
return 2;
}
return 0;
}
void CameraItemPropertiesTab::setCurrentItem(const CamItemInfo& itemInfo, const DMetadata& meta)
{
if (itemInfo.isNull())
{
d->labelFile->setAdjustedText(QString());
d->labelFolder->setAdjustedText(QString());
d->labelFileIsReadable->setAdjustedText(QString());
d->labelFileIsWritable->setAdjustedText(QString());
d->labelFileDate->setAdjustedText(QString());
d->labelFileSize->setAdjustedText(QString());
d->labelImageMime->setAdjustedText(QString());
d->labelImageDimensions->setAdjustedText(QString());
d->labelImageRatio->setAdjustedText(QString());
d->labelNewFileName->setAdjustedText(QString());
d->labelAlreadyDownloaded->setAdjustedText(QString());
d->labelPhotoMake->setAdjustedText(QString());
d->labelPhotoModel->setAdjustedText(QString());
d->labelPhotoDateTime->setAdjustedText(QString());
d->labelPhotoLens->setAdjustedText(QString());
d->labelPhotoAperture->setAdjustedText(QString());
d->labelPhotoFocalLength->setAdjustedText(QString());
d->labelPhotoExposureTime->setAdjustedText(QString());
d->labelPhotoSensitivity->setAdjustedText(QString());
d->labelPhotoExposureMode->setAdjustedText(QString());
d->labelPhotoFlash->setAdjustedText(QString());
d->labelPhotoWhiteBalance->setAdjustedText(QString());
d->labelVideoAspectRatio->setAdjustedText(QString());
d->labelVideoAudioBitRate->setAdjustedText(QString());
d->labelVideoAudioChannelType->setAdjustedText(QString());
d->labelVideoAudioCompressor->setAdjustedText(QString());
d->labelVideoDuration->setAdjustedText(QString());
d->labelVideoFrameRate->setAdjustedText(QString());
d->labelVideoVideoCodec->setAdjustedText(QString());
setEnabled(false);
return;
}
setEnabled(true);
QString str;
QString unknown(i18n("<i>unknown</i>"));
// -- Camera file system information ------------------------------------------
d->labelFile->setAdjustedText(itemInfo.name);
d->labelFolder->setAdjustedText(itemInfo.folder);
if (itemInfo.readPermissions < 0)
{
str = unknown;
}
else if (itemInfo.readPermissions == 0)
{
str = i18n("No");
}
else
{
str = i18n("Yes");
}
d->labelFileIsReadable->setAdjustedText(str);
if (itemInfo.writePermissions < 0)
{
str = unknown;
}
else if (itemInfo.writePermissions == 0)
{
str = i18n("No");
}
else
{
str = i18n("Yes");
}
d->labelFileIsWritable->setAdjustedText(str);
if (itemInfo.ctime.isValid())
{
d->labelFileDate->setAdjustedText(QLocale().toString(itemInfo.ctime, QLocale::ShortFormat));
}
else
{
d->labelFileDate->setAdjustedText(unknown);
}
str = i18n("%1 (%2)", ImagePropertiesTab::humanReadableBytesCount(itemInfo.size), QLocale().toString(itemInfo.size));
d->labelFileSize->setAdjustedText(str);
// -- Image Properties --------------------------------------------------
if (itemInfo.mime == QLatin1String("image/x-raw"))
{
d->labelImageMime->setAdjustedText(i18n("RAW Image"));
}
else
{
QMimeType mimeType = QMimeDatabase().mimeTypeForName(itemInfo.mime);
if (mimeType.isValid())
{
d->labelImageMime->setAdjustedText(mimeType.comment());
}
else
{
d->labelImageMime->setAdjustedText(itemInfo.mime); // last fallback
}
}
QString mpixels;
QSize dims;
if (itemInfo.width == -1 && itemInfo.height == -1)
{
// delayed loading to list faster from UMSCamera
if (itemInfo.mime == QLatin1String("image/x-raw"))
{
dims = meta.getImageDimensions();
}
else
{
dims = meta.getPixelSize();
}
}
else
{
// if available (GPCamera), take dimensions directly from itemInfo
dims = QSize(itemInfo.width, itemInfo.height);
}
mpixels.setNum(dims.width()*dims.height()/1000000.0, 'f', 2);
str = (!dims.isValid()) ? unknown : i18n("%1x%2 (%3Mpx)",
dims.width(), dims.height(), mpixels);
d->labelImageDimensions->setAdjustedText(str);
if (!dims.isValid()) str = unknown;
else ImagePropertiesTab::aspectRatioToString(dims.width(), dims.height(), str);
d->labelImageRatio->setAdjustedText(str);
// -- Download information ------------------------------------------
d->labelNewFileName->setAdjustedText(itemInfo.downloadName.isEmpty() ? i18n("<i>unchanged</i>") : itemInfo.downloadName);
if (itemInfo.downloaded == CamItemInfo::DownloadUnknown)
{
str = unknown;
}
else if (itemInfo.downloaded == CamItemInfo::DownloadedYes)
{
str = i18n("Yes");
}
else
{
str = i18n("No");
}
d->labelAlreadyDownloaded->setAdjustedText(str);
// -- Photograph information ------------------------------------------
// Note: If something is changed here, please updated albumfiletip section too.
QString unavailable(i18n("<i>unavailable</i>"));
PhotoInfoContainer photoInfo = meta.getPhotographInformation();
if (photoInfo.isEmpty())
{
widget(1)->hide();
}
else
{
widget(1)->show();
}
ImagePropertiesTab::shortenedMakeInfo(photoInfo.make);
ImagePropertiesTab::shortenedModelInfo(photoInfo.model);
d->labelPhotoMake->setAdjustedText(photoInfo.make.isEmpty() ? unavailable : photoInfo.make);
d->labelPhotoModel->setAdjustedText(photoInfo.model.isEmpty() ? unavailable : photoInfo.model);
if (photoInfo.dateTime.isValid())
{
str = QLocale().toString(photoInfo.dateTime, QLocale::ShortFormat);
d->labelPhotoDateTime->setAdjustedText(str);
}
else
{
d->labelPhotoDateTime->setAdjustedText(unavailable);
}
d->labelPhotoLens->setAdjustedText(photoInfo.lens.isEmpty() ? unavailable : photoInfo.lens);
d->labelPhotoAperture->setAdjustedText(photoInfo.aperture.isEmpty() ? unavailable : photoInfo.aperture);
if (photoInfo.focalLength35mm.isEmpty())
{
d->labelPhotoFocalLength->setAdjustedText(photoInfo.focalLength.isEmpty() ? unavailable : photoInfo.focalLength);
}
else
{
str = i18n("%1 (%2)", photoInfo.focalLength, photoInfo.focalLength35mm);
d->labelPhotoFocalLength->setAdjustedText(str);
}
d->labelPhotoExposureTime->setAdjustedText(photoInfo.exposureTime.isEmpty() ? unavailable : photoInfo.exposureTime);
d->labelPhotoSensitivity->setAdjustedText(photoInfo.sensitivity.isEmpty() ? unavailable : i18n("%1 ISO", photoInfo.sensitivity));
if (photoInfo.exposureMode.isEmpty() && photoInfo.exposureProgram.isEmpty())
{
d->labelPhotoExposureMode->setAdjustedText(unavailable);
}
else if (!photoInfo.exposureMode.isEmpty() && photoInfo.exposureProgram.isEmpty())
{
d->labelPhotoExposureMode->setAdjustedText(photoInfo.exposureMode);
}
else if (photoInfo.exposureMode.isEmpty() && !photoInfo.exposureProgram.isEmpty())
{
d->labelPhotoExposureMode->setAdjustedText(photoInfo.exposureProgram);
}
else
{
str = QString::fromUtf8("%1 / %2").arg(photoInfo.exposureMode).arg(photoInfo.exposureProgram);
d->labelPhotoExposureMode->setAdjustedText(str);
}
d->labelPhotoFlash->setAdjustedText(photoInfo.flash.isEmpty() ? unavailable : photoInfo.flash);
d->labelPhotoWhiteBalance->setAdjustedText(photoInfo.whiteBalance.isEmpty() ? unavailable : photoInfo.whiteBalance);
// -- Video information ------------------------------------------
VideoInfoContainer videoInfo = meta.getVideoInformation();
if (videoInfo.isEmpty())
{
widget(2)->hide();
}
else
{
widget(2)->show();
}
d->labelVideoAspectRatio->setAdjustedText(videoInfo.aspectRatio.isEmpty() ? unavailable : videoInfo.aspectRatio);
d->labelVideoAudioBitRate->setAdjustedText(videoInfo.audioBitRate.isEmpty() ? unavailable : videoInfo.audioBitRate);
d->labelVideoAudioChannelType->setAdjustedText(videoInfo.audioChannelType.isEmpty() ? unavailable : videoInfo.audioChannelType);
d->labelVideoAudioCompressor->setAdjustedText(videoInfo.audioCompressor.isEmpty() ? unavailable : videoInfo.audioCompressor);
d->labelVideoDuration->setAdjustedText(videoInfo.duration.isEmpty() ? unavailable : videoInfo.duration);
d->labelVideoFrameRate->setAdjustedText(videoInfo.frameRate.isEmpty() ? unavailable : videoInfo.frameRate);
d->labelVideoVideoCodec->setAdjustedText(videoInfo.videoCodec.isEmpty() ? unavailable : videoInfo.videoCodec);
}
QVariant DirModel::data(const QModelIndex &index, int role) const
{
//its not for QML
#if defined(REGRESSION_TEST_FOLDERLISTMODEL)
if (!index.isValid() ||
(role != Qt::DisplayRole && role != Qt::DecorationRole && role != Qt::BackgroundRole)
)
{
return QVariant();
}
if (role == Qt::DecorationRole && index.column() == 0)
{
QIcon icon;
QMimeType mime = mDirectoryContents.at(index.row()).mimeType();
if (mime.isValid())
{
if (QIcon::hasThemeIcon(mime.iconName()) ) {
icon = QIcon::fromTheme(mime.iconName());
}
else if (QIcon::hasThemeIcon(mime.genericIconName())) {
icon = QIcon::fromTheme(mime.genericIconName());
}
}
if (icon.isNull())
{
if (mDirectoryContents.at(index.row()).isLocal())
{
icon = QFileIconProvider().icon(mDirectoryContents.at(index.row()).diskFileInfo());
}
else
if (mDirectoryContents.at(index.row()).isDir())
{
icon = QFileIconProvider().icon(QFileIconProvider::Folder);
}
else
{
icon = QFileIconProvider().icon(QFileIconProvider::File);
}
}
return icon;
}
if (role == Qt::BackgroundRole && index.column() == 0)
{
if (mDirectoryContents.at(index.row()).isSelected())
{
//TODO it'd better to get some style or other default
// background color
return QBrush(Qt::lightGray);
}
return QVariant();
}
role = FileNameRole + index.column();
#else
if (role < FileNameRole || role > TrackCoverRole) {
qWarning() << Q_FUNC_INFO << this << "Got an out of range role: " << role;
return QVariant();
}
if (index.row() < 0 || index.row() >= mDirectoryContents.count()) {
qWarning() << "Attempted to access out of range row: " << index.row();
return QVariant();
}
if (index.column() != 0)
return QVariant();
#endif
const DirItemInfo &fi = mDirectoryContents.at(index.row());
switch (role) {
case FileNameRole:
return fi.fileName();
case AccessedDateRole:
return fi.lastRead();
case CreationDateRole:
return fi.created();
case ModifiedDateRole:
return fi.lastModified();
case FileSizeRole: {
if (fi.isDir() && fi.isLocal())
{
return dirItems(fi.diskFileInfo());
}
return fileSize(fi.size());
}
case IconSourceRole: {
const QString &fileName = fi.fileName();
if (fi.isDir())
return QLatin1String("image://theme/icon-m-common-directory");
if (fileName.endsWith(QLatin1String(".jpg"), Qt::CaseInsensitive) ||
fileName.endsWith(QLatin1String(".png"), Qt::CaseInsensitive)) {
return QLatin1String("image://nemoThumbnail/") + fi.filePath();
}
return "image://theme/icon-m-content-document";
}
case FilePathRole:
return fi.filePath();
case MimeTypeRole:
return fi.mimeType().name();
case MimeTypeDescriptionRole:
return fi.mimeType().comment();
case IsDirRole:
return fi.isDir();
case IsFileRole:
return !fi.isDir();
case IsReadableRole:
return fi.isReadable();
case IsWritableRole:
return fi.isWritable();
case IsExecutableRole:
return fi.isExecutable();
case IsSelectedRole:
return fi.isSelected();
#ifndef DO_NOT_USE_TAG_LIB
case TrackTitleRole:
case TrackArtistRole:
case TrackAlbumRole:
case TrackYearRole:
case TrackNumberRole:
case TrackGenreRole:
case TrackLengthRole:
case TrackCoverRole:
if (mReadsMediaMetadata && fi.isLocal())
{
return getAudioMetaData(fi.diskFileInfo(), role);
}
break;
#endif
default:
#if !defined(REGRESSION_TEST_FOLDERLISTMODEL)
// this should not happen, ever
Q_ASSERT(false);
qWarning() << Q_FUNC_INFO << this << "Got an unknown role: " << role;
#endif
break;
}
return QVariant();
}
