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();
}
QString AddToArchive::detectBaseName(const QStringList &paths) const
{
QFileInfo fileInfo = QFileInfo(paths.first());
QDir parentDir = fileInfo.dir();
QString base = parentDir.absolutePath() + QLatin1Char('/');
if (paths.size() > 1) {
if (!parentDir.isRoot()) {
// Use directory name for the new archive.
base += parentDir.dirName();
}
} else {
// Strip filename of its extension, but only if present (see #362690).
if (!QMimeDatabase().mimeTypeForFile(fileInfo.fileName(), QMimeDatabase::MatchExtension).isDefault()) {
base += fileInfo.completeBaseName();
} else {
base += fileInfo.fileName();
}
}
// Special case for compressed tar archives.
if (base.right(4).toUpper() == QLatin1String(".TAR")) {
base.chop(4);
}
if (base.endsWith(QLatin1Char('/'))) {
base.chop(1);
}
return base;
}
void QNetworkReplyHandler::sendResponseIfNeeded()
{
ASSERT(m_replyWrapper && m_replyWrapper->reply() && !wasAborted());
if (m_replyWrapper->reply()->error() && m_replyWrapper->reply()->attribute(QNetworkRequest::HttpStatusCodeAttribute).isNull())
return;
ResourceHandleClient* client = m_resourceHandle->client();
if (!client)
return;
WTF::String mimeType = m_replyWrapper->mimeType();
if (mimeType.isEmpty()) {
// let's try to guess from the extension
mimeType = MIMETypeRegistry::getMIMETypeForPath(m_replyWrapper->reply()->url().path());
}
KURL url(m_replyWrapper->reply()->url());
ResourceResponse response(url, mimeType.lower(),
m_replyWrapper->reply()->header(QNetworkRequest::ContentLengthHeader).toLongLong(),
m_replyWrapper->encoding(), String());
if (url.isLocalFile()) {
client->didReceiveResponse(m_resourceHandle, response);
return;
}
// The status code is equal to 0 for protocols not in the HTTP family.
int statusCode = m_replyWrapper->reply()->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
if (url.protocolIsInHTTPFamily()) {
String suggestedFilename = filenameFromHTTPContentDisposition(QString::fromLatin1(m_replyWrapper->reply()->rawHeader("Content-Disposition")));
if (!suggestedFilename.isEmpty())
response.setSuggestedFilename(suggestedFilename);
else {
Vector<String> extensions = MIMETypeRegistry::getExtensionsForMIMEType(mimeType);
if (extensions.isEmpty())
response.setSuggestedFilename(url.lastPathComponent());
else {
// If the suffix doesn't match the MIME type, correct the suffix.
QString filename = url.lastPathComponent();
const String suffix = QMimeDatabase().suffixForFileName(filename);
if (!extensions.contains(suffix)) {
filename.chop(suffix.length());
filename += MIMETypeRegistry::getPreferredExtensionForMIMEType(mimeType);
}
response.setSuggestedFilename(filename);
}
}
response.setHTTPStatusCode(statusCode);
response.setHTTPStatusText(m_replyWrapper->reply()->attribute(QNetworkRequest::HttpReasonPhraseAttribute).toByteArray().constData());
// Add remaining headers.
foreach (const QNetworkReply::RawHeaderPair& pair, m_replyWrapper->reply()->rawHeaderPairs())
response.setHTTPHeaderField(QString::fromLatin1(pair.first), QString::fromLatin1(pair.second));
}
MimeType MimeTypeForData(const QByteArray &data) {
if (data.size() >= 12) {
if (!memcmp(data.constData(), "RIFF", 4) && !memcmp(data.constData() + 8, "WEBP", 4)) {
return MimeType(MimeType::Known::WebP);
}
}
return MimeType(QMimeDatabase().mimeTypeForData(data));
}
QMimeType QtWebEngineTransfer::getMimeType() const
{
if (!m_item)
{
return Transfer::getMimeType();
}
return QMimeDatabase().mimeTypeForName(m_item->mimeType());
}
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);
}
}
void KompareShell::slotFileOpen()
{
// FIXME: use different filedialog which gets encoding
QUrl url = QFileDialog::getOpenFileUrl( this, QString(), QUrl(), QMimeDatabase().mimeTypeForName("text/x-patch").filterString() );
if( !url.isEmpty() ) {
KompareShell* shell = new KompareShell();
shell->show();
shell->openDiff( url );
}
}
void ShowFoto::slotDroppedUrls(const QList<QUrl>& droppedUrls)
{
if (!droppedUrls.isEmpty())
{
QList<QUrl> validUrls;
foreach (const QUrl& url, droppedUrls)
{
if (url.isValid())
{
validUrls << url;
}
}
d->droppedUrls = true;
QList<QUrl> imagesUrls;
QList<QUrl> foldersUrls;
foreach (const QUrl& url, validUrls)
{
if (QMimeDatabase().mimeTypeForUrl(url).name().startsWith(QLatin1String("image"), Qt::CaseInsensitive))
{
imagesUrls << url;
}
if (QMimeDatabase().mimeTypeForUrl(url).name() == QLatin1String("inode/directory"))
{
foldersUrls << url;
}
}
if (!imagesUrls.isEmpty())
{
openUrls(imagesUrls);
}
if (!foldersUrls.isEmpty())
{
foreach (const QUrl& fUrl, foldersUrls)
{
openFolder(fUrl);
}
MimeType MimeTypeForName(const QString &mime) {
if (mime == qsl("image/webp")) {
return MimeType(MimeType::Known::WebP);
} else if (mime == qsl("application/x-tdesktop-theme")) {
return MimeType(MimeType::Known::TDesktopTheme);
} else if (mime == qsl("application/x-tdesktop-palette")) {
return MimeType(MimeType::Known::TDesktopPalette);
}
return MimeType(QMimeDatabase().mimeTypeForName(mime));
}
void ImgurUploader::upload(const QString &fileName)
{
QFile *file = new QFile(fileName);
if (!file->open(QIODevice::ReadOnly)) {
emit error(ImageUploader::FileError, tr("Unable to read screenshot file"), fileName);
file->deleteLater();
return;
}
QNetworkRequest request(QUrl("https://api.imgur.com/3/image"));
request.setRawHeader("Authorization", QString("Client-ID %1").arg(clientId()).toLatin1());
QHttpMultiPart *multiPart = new QHttpMultiPart(QHttpMultiPart::FormDataType);
if (!mSettings.value("anonymous", true).toBool()) {
request.setRawHeader("Authorization", QByteArray("Bearer ") + mSettings.value("access_token").toByteArray());
if (!mSettings.value("album").toString().isEmpty()) {
QHttpPart albumPart;
albumPart.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant("form-data; name=\"album\""));
albumPart.setBody(mSettings.value("album").toByteArray());
multiPart->append(albumPart);
}
}
QHttpPart imagePart;
imagePart.setHeader(QNetworkRequest::ContentTypeHeader, QMimeDatabase().mimeTypeForFile(fileName, QMimeDatabase::MatchExtension).name());
imagePart.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant("form-data; name=\"image\""));
imagePart.setBodyDevice(file);
file->setParent(multiPart);
multiPart->append(imagePart);
QNetworkReply *reply = Uploader::network()->post(request, multiPart);
reply->setProperty("fileName", fileName);
this->setProperty("fileName", fileName);
multiPart->setParent(reply);
#ifdef Q_OS_WIN
connect(reply, &QNetworkReply::sslErrors, [reply](const QList<QSslError> &errors) {
Q_UNUSED(errors);
if (QSysInfo::WindowsVersion <= QSysInfo::WV_2003) {
reply->ignoreSslErrors();
}
});
#endif
connect(reply, &QNetworkReply::uploadProgress, this, &ImgurUploader::uploadProgress);
connect(this , &ImgurUploader::cancelRequest, reply, &QNetworkReply::abort);
connect(this , &ImgurUploader::cancelRequest, reply, &QNetworkReply::deleteLater);
connect(reply, &QNetworkReply::finished, this, &ImgurUploader::finished);
}
KService::List FileOperation::servicesForOpenWith(const QList<QUrl>& urls)
{
// This code is inspired by KonqMenuActions:
// kdebase/apps/lib/konq/konq_menuactions.cpp
QStringList mimeTypes;
KService::List offers;
foreach(const QUrl& item, urls)
{
const QString mimeType = QMimeDatabase().mimeTypeForFile(item.path(), QMimeDatabase::MatchExtension).name();
if (!mimeTypes.contains(mimeType))
{
mimeTypes << mimeType;
}
}
if (!mimeTypes.isEmpty())
{
// Query trader
const QString firstMimeType = mimeTypes.takeFirst();
const QString constraintTemplate = QLatin1String("'%1' in ServiceTypes");
QStringList constraints;
foreach(const QString& mimeType, mimeTypes)
{
constraints << constraintTemplate.arg(mimeType);
}
offers = KMimeTypeTrader::self()->query(firstMimeType, QLatin1String("Application"), constraints.join(QLatin1String(" and ")));
// remove duplicate service entries
QSet<QString> seenApps;
for (KService::List::iterator it = offers.begin(); it != offers.end();)
{
const QString appName((*it)->name());
if (!seenApps.contains(appName))
{
seenApps.insert(appName);
++it;
}
else
{
it = offers.erase(it);
}
}
}
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();
}
bool Helper::handleGetFromExtension()
{
if( !readArguments( 1 ))
return false;
QString ext = getArgument();
if( !allArgumentsUsed())
return false;
if( !ext.isEmpty()) {
QList<QMimeType> mimeList = QMimeDatabase().mimeTypesForFileName("foo." + ext);
for (const QMimeType &mime : mimeList)
if (mime.isValid() && writeMimeInfo(mime))
return true;
return false;
}
return false;
}
bool showSaveAsDialog(const QUrl &url, QUrl* outUrl, QByteArray* format)
{
KFileDialog dialog(url, QString(), mMainWindow);
dialog.setOperationMode(KFileDialog::Saving);
dialog.setSelection(url.fileName());
QStringList supportedMimetypes;
for (const QByteArray &mimeName : QImageWriter::supportedMimeTypes()) {
supportedMimetypes.append(QString::fromLocal8Bit(mimeName));
}
dialog.setMimeFilter(
supportedMimetypes,
MimeTypeUtils::urlMimeType(url) // Default
);
// Show dialog
do {
if (!dialog.exec()) {
return false;
}
const QString mimeType = dialog.currentMimeFilter();
if (mimeType.isEmpty()) {
KMessageBox::sorry(
mMainWindow,
i18nc("@info",
"No image format selected.")
);
continue;
}
const QStringList typeList = QMimeDatabase().mimeTypeForName(mimeType).suffixes();
if (typeList.count() > 0) {
*format = typeList[0].toAscii();
break;
}
KMessageBox::sorry(
mMainWindow,
i18nc("@info",
"Gwenview cannot save images as %1.", mimeType)
);
} while (true);
*outUrl = dialog.selectedUrl();
return true;
}
void FileOperation::openFilesWithDefaultApplication(const QList<QUrl>& urls, QWidget* const parentWidget)
{
if (urls.isEmpty())
{
return;
}
// Create a map of service depending of type mimes to route and start only one instance of relevant application with all same type mime files.
QMap<KService::Ptr, QList<QUrl>> servicesMap;
foreach (const QUrl& url, urls)
{
const QString mimeType = QMimeDatabase().mimeTypeForFile(url.path(), QMimeDatabase::MatchExtension).name();
KService::List offers = KMimeTypeTrader::self()->query(mimeType, QLatin1String("Application"));
if (offers.isEmpty())
{
return;
}
KService::Ptr ptr = offers.first();
QMap<KService::Ptr, QList<QUrl>>::const_iterator it = servicesMap.constFind(ptr);
if (it != servicesMap.constEnd())
{
servicesMap[ptr] << url;
}
else
{
servicesMap.insert(ptr, QList<QUrl>() << url);
}
}
for (QMap<KService::Ptr, QList<QUrl>>::const_iterator it = servicesMap.constBegin();
it != servicesMap.constEnd(); ++it)
{
// Run the dedicated app to open the item.
#if KIO_VERSION < QT_VERSION_CHECK(5,6,0)
KRun::run(*it.key(), it.value(), parentWidget);
#else
KRun::runService(*it.key(), it.value(), parentWidget);
#endif
}
}
void FolderFilesList::checkNextItem(const QFileInfo &item)
{
if (m_cancelSearch) {
return;
}
if (item.isFile()) {
if (!m_binary) {
QMimeType mimeType = QMimeDatabase().mimeTypeForFile(item);
if (!mimeType.inherits(QStringLiteral("text/plain"))) {
return;
}
}
m_files << item.absoluteFilePath();
}
else {
QDir currentDir(item.absoluteFilePath());
if (!currentDir.isReadable()) {
qDebug() << currentDir.absolutePath() << "Not readable";
return;
}
QDir::Filters filter = QDir::Files | QDir::NoDotAndDotDot | QDir::Readable;
if (m_hidden) filter |= QDir::Hidden;
if (m_recursive) filter |= QDir::AllDirs;
if (!m_symlinks) filter |= QDir::NoSymLinks;
// sort the items to have an deterministic order!
const QFileInfoList currentItems = currentDir.entryInfoList(m_types, filter, QDir::Name | QDir::LocaleAware);
bool skip;
for (int i = 0; i<currentItems.size(); ++i) {
skip = false;
for (int j=0; j<m_excludeList.size(); j++) {
if (m_excludeList[j].exactMatch(currentItems[i].fileName())) {
skip = true;
break;
}
}
if (!skip) {
checkNextItem(currentItems[i]);
}
}
}
}
QIcon CTTask::commandIcon() const {
QUrl commandPath = QUrl::fromLocalFile(completeCommandPath());
QMimeType mimeType = QMimeDatabase().mimeTypeForUrl(commandPath);
//logDebug() << mimeType->name() << endl;
if (mimeType.name() == QLatin1String( "application/x-executable" ) || mimeType.name() == QLatin1String( "application/octet-stream" )) {
//The next line is identical as SmallIcon(commandPath.fileName()), but is able to return a isNull() QPixmap
QPixmap pixmap = KIconLoader::global()->loadIcon(commandPath.fileName(), KIconLoader::Small, 0, KIconLoader::DefaultState, QStringList(), 0L, true);
if (pixmap.isNull()) {
return QIcon::fromTheme(QLatin1String("system-run"));
}
return QIcon(pixmap);
}
return QIcon::fromTheme(mimeType.iconName());
}
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;
}
bool ParupaintPanvasInputOutput::loadPanvas(ParupaintPanvas * panvas, const QString & filename, QString & errorStr)
{
Q_ASSERT(panvas);
QFileInfo file(filename);
if(!file.exists())
return (errorStr = "File " + filename + " doesn't exist.").isEmpty();
QMimeType type = QMimeDatabase().mimeTypeForFile(file);
if(type.name().endsWith("png") || type.name().endsWith("jpg")){
return ParupaintPanvasInputOutput::loadImage(panvas, file.filePath(), errorStr);
} else if(type.name().endsWith("gif")){
return ParupaintPanvasInputOutput::loadGIF(panvas, file.filePath(), errorStr);
} else if(type.name().endsWith("openraster")){
return ParupaintPanvasInputOutput::loadORA(panvas, file.filePath(), errorStr);
} else if(type.name().endsWith("zip")){
return ParupaintPanvasInputOutput::loadPPA(panvas, file.filePath(), errorStr);
}
return (errorStr = "File format not recognized.").isEmpty();
}
void ApplyChangesWidgetPrivate::createEditPart(const IndexedString & file)
{
QWidget * widget = m_documentTabs->currentWidget();
Q_ASSERT(widget);
QVBoxLayout *m=new QVBoxLayout(widget);
QSplitter *v=new QSplitter(widget);
m->addWidget(v);
QUrl url = file.toUrl();
QMimeType mimetype = QMimeDatabase().mimeTypeForUrl(url);
KParts::ReadWritePart* part=KMimeTypeTrader::self()->createPartInstanceFromQuery<KParts::ReadWritePart>(mimetype.name(), widget, widget);
KTextEditor::Document* document=qobject_cast<KTextEditor::Document*>(part);
Q_ASSERT(document);
Q_ASSERT(document->action("file_save"));
document->action("file_save")->setEnabled(false);
m_editParts.insert(m_index, part);
//Open the best code representation, even if it is artificial
CodeRepresentation::Ptr repr = createCodeRepresentation(file);
if(!repr->fileExists())
{
const QString templateName = QDir::tempPath() + QLatin1Char('/') + url.fileName().split('.').last();
QTemporaryFile * temp(new QTemporaryFile(templateName));
temp->open();
temp->write(repr->text().toUtf8());
temp->close();
url = QUrl::fromLocalFile(temp->fileName());
m_temps << temp;
}
m_editParts[m_index]->openUrl(url);
v->addWidget(m_editParts[m_index]->widget());
v->setSizes(QList<int>() << 400 << 100);
}
void RoomMenu::upload_file(const QString &path) {
auto file = std::make_shared<QFile>(path);
QFileInfo info(*file);
if(!file->open(QIODevice::ReadOnly)) {
MessageBox::critical(tr("Error opening file"), tr("Couldn't open %1: %2").arg(info.fileName()).arg(file->errorString()), parentWidget());
return;
}
const QString &type = QMimeDatabase().mimeTypeForFile(info).name();
auto reply = room_.session().upload(*file, type, info.fileName());
QPointer<matrix::Room> room(&room_);
// This closure captures 'file' to ensure its outlives the network request
connect(reply, &matrix::ContentPost::success, [file, room, info, type](const QString &uri) {
if(!room) return;
room->send_file(uri, info.fileName(), type, info.size());
});
QPointer<QWidget> parent(parentWidget());
connect(reply, &matrix::ContentPost::error, [parent, info](const QString &msg) {
MessageBox::critical(tr("Error uploading file"), tr("Couldn't upload %1: %2").arg(info.fileName()).arg(msg), parent);
});
}
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;
}
void MainWindow::saveAs()
{
const auto formats = ImageIO::supportedImageFormats(ImageFormatInfo::CanWrite);
const auto filters = tr("All Files (*);;") + mimeTypesToFilters(formatsToMimeTypes(formats));
const auto path = QFileDialog::getSaveFileName(this, tr("Save As"), QString(), filters);
if (path.isEmpty())
return;
const auto mt = QMimeDatabase().mimeTypeForFile(path);
const auto info = ImageIO::imageFormat(mt);
if (!info) {
QMessageBox::warning(this, tr("Save"), tr("No format for mimetype %1").arg(mt.name()));
return;
}
SaveOptionsDialog dialog;
dialog.setImageFormat(*info);
if (dialog.exec() == QDialog::Rejected)
return;
saveDocument(QUrl::fromLocalFile(path), dialog.subType(), dialog.options());
}
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?
}
}
MimeType MimeTypeForFile(const QFileInfo &file) {
QString path = file.absoluteFilePath();
if (path.endsWith(qstr(".webp"), Qt::CaseInsensitive)) {
return MimeType(MimeType::Known::WebP);
} else if (path.endsWith(qstr(".tdesktop-theme"), Qt::CaseInsensitive)) {
return MimeType(MimeType::Known::TDesktopTheme);
} else if (path.endsWith(qstr(".tdesktop-palette"), Qt::CaseInsensitive)) {
return MimeType(MimeType::Known::TDesktopPalette);
}
{
QFile f(path);
if (f.open(QIODevice::ReadOnly)) {
QByteArray magic = f.read(12);
if (magic.size() >= 12) {
if (!memcmp(magic.constData(), "RIFF", 4) && !memcmp(magic.constData() + 8, "WEBP", 4)) {
return MimeType(MimeType::Known::WebP);
}
}
f.close();
}
}
return MimeType(QMimeDatabase().mimeTypeForFile(file));
}
void KateProjectTreeViewContextMenu::exec(const QString &filename, const QPoint &pos, QWidget *parent)
{
/**
* create context menu
*/
QMenu menu;
QAction *copyAction = menu.addAction(QIcon::fromTheme(QStringLiteral("edit-copy")), i18n("Copy Filename"));
/**
* handle "open with"
* find correct mimetype to query for possible applications
*/
QMenu *openWithMenu = menu.addMenu(i18n("Open With"));
QMimeType mimeType = QMimeDatabase().mimeTypeForFile(filename);
KService::List offers = KMimeTypeTrader::self()->query(mimeType.name(), QStringLiteral("Application"));
/**
* for each one, insert a menu item...
*/
for (KService::List::Iterator it = offers.begin(); it != offers.end(); ++it) {
KService::Ptr service = *it;
if (service->name() == QStringLiteral("Kate")) {
continue; // omit Kate
}
QAction *action = openWithMenu->addAction(QIcon::fromTheme(service->icon()), service->name());
action->setData(service->entryPath());
}
/**
* perhaps disable menu, if no entries!
*/
openWithMenu->setEnabled(!openWithMenu->isEmpty());
KMoreToolsMenuFactory menuFactory(QLatin1String("kate/addons/project/git-tools"));
QMenu gitMenu; // must live as long as the maybe filled menu items should live
if (isGit(filename)) {
menuFactory.fillMenuFromGroupingNames(&gitMenu, { QLatin1String("git-clients-and-actions") },
QUrl::fromLocalFile(filename));
menu.addSection(i18n("Git:"));
Q_FOREACH(auto action, gitMenu.actions()) {
menu.addAction(action);
}
}
/**
* run menu and handle the triggered action
*/
if (QAction *action = menu.exec(pos)) {
// handle apps
if (copyAction == action) {
QApplication::clipboard()->setText(filename);
} else {
// handle "open with"
const QString openWith = action->data().toString();
if (KService::Ptr app = KService::serviceByDesktopPath(openWith)) {
QList<QUrl> list;
list << QUrl::fromLocalFile(filename);
KRun::runService(*app, list, parent);
}
}
}
}
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);
}
void PomfUploader::upload(const QString &fileName)
{
QString pomfUrl = mSettings["pomf_url"].toString();
if (pomfUrl.isEmpty()) {
emit error(ImageUploader::HostError, tr("Invalid pomf uploader URL!"), fileName);
return;
}
QUrl url = QUrl::fromUserInput(pomfUrl + "/upload.php");
QFile *file = new QFile(fileName);
if (!file->open(QIODevice::ReadOnly)) {
emit error(ImageUploader::FileError, tr("Unable to read screenshot file"), fileName);
file->deleteLater();
return;
}
QNetworkRequest request(url);
QHttpMultiPart *multiPart = new QHttpMultiPart(QHttpMultiPart::FormDataType);
QHttpPart imagePart;
imagePart.setHeader(QNetworkRequest::ContentTypeHeader, QMimeDatabase().mimeTypeForFile(fileName, QMimeDatabase::MatchExtension).name());
imagePart.setHeader(QNetworkRequest::ContentDispositionHeader, QString("form-data; name=\"files[]\"; filename=\"%1\"").arg(QFileInfo(fileName).fileName()));
imagePart.setBodyDevice(file);
file->setParent(multiPart);
multiPart->append(imagePart);
QNetworkReply *reply = Uploader::network()->post(request, multiPart);
this->setProperty("fileName", fileName);
multiPart->setParent(reply);
connect(this , &PomfUploader::cancelRequest, reply, &QNetworkReply::abort);
connect(this , &PomfUploader::cancelRequest, reply, &QNetworkReply::deleteLater);
connect(reply, &QNetworkReply::uploadProgress, this, [&](qint64 bytesSent, qint64 bytesTotal) {
float b = (float) bytesSent / bytesTotal;
int p = qRound(b * 100);
setProgress(p);
});
connect(reply, &QNetworkReply::finished, this, [&, reply, fileName] {
const QJsonObject pomfResponse = QJsonDocument::fromJson(reply->readAll()).object();
if (reply->error() != QNetworkReply::NoError && pomfResponse.isEmpty()) {
emit error(ImageUploader::NetworkError, tr("Error reaching uploader"), fileName);
return;
}
if (!pomfResponse.contains("success") || !pomfResponse.contains("files")) {
emit error(ImageUploader::HostError, tr("Invalid response from uploader"), fileName);
return;
}
if (pomfResponse["success"].toBool()) {
emit uploaded(fileName, pomfResponse["files"].toArray().at(0).toObject()["url"].toString(), "");
} else {
QString description;
if (pomfResponse.contains("description")) {
description = pomfResponse["description"].toString();
}
if (description.isEmpty()) {
description = tr("Host error");
}
emit error(ImageUploader::HostError, description, fileName);
}
});
connect(reply, &QNetworkReply::sslErrors, [reply](const QList<QSslError> &errors) {
Q_UNUSED(errors);
if (QSysInfo::WindowsVersion == QSysInfo::WV_XP) {
reply->ignoreSslErrors();
}
});
}
void LocalImageLoaderPrivate::prepareImages() {
QString file, filename, mime;
int32 filesize = 0;
QImage img;
QByteArray data;
PeerId peer;
uint64 id, jpeg_id = 0;
ToPrepareMediaType type;
{
QMutexLocker lock(loader->toPrepareMutex());
ToPrepareMedias &list(loader->toPrepareMedias());
if (list.isEmpty()) return;
file = list.front().file;
img = list.front().img;
data = list.front().data;
peer = list.front().peer;
id = list.front().id;
type = list.front().type;
}
if (img.isNull()) {
if (!file.isEmpty()) {
QFileInfo info(file);
if (type == ToPrepareAuto) {
QString lower(file.toLower());
const QStringList &photoExtensions(cPhotoExtensions());
for (QStringList::const_iterator i = photoExtensions.cbegin(), e = photoExtensions.cend(); i != e; ++i) {
if (lower.lastIndexOf(*i) == lower.size() - i->size()) {
if (info.size() < MaxUploadPhotoSize) {
type = ToPreparePhoto;
break;
}
}
}
if (type == ToPrepareAuto && info.size() < MaxUploadDocumentSize) {
type = ToPrepareDocument;
}
}
if (type != ToPrepareAuto && info.size() < MaxUploadPhotoSize) {
img = App::readImage(file);
}
if (type == ToPrepareDocument) {
mime = QMimeDatabase().mimeTypeForFile(info).name();
}
filename = info.fileName();
filesize = info.size();
} else if (!data.isEmpty()) {
img = App::readImage(data);
if (type == ToPrepareAuto) {
if (!img.isNull() && data.size() < MaxUploadPhotoSize) {
type = ToPreparePhoto;
} else if (data.size() < MaxUploadDocumentSize) {
type = ToPrepareDocument;
} else {
img = QImage();
}
}
QMimeType mimeType = QMimeDatabase().mimeTypeForData(data);
if (type == ToPrepareDocument) {
mime = mimeType.name();
}
filename = qsl("Document");
QStringList patterns = mimeType.globPatterns();
if (!patterns.isEmpty()) {
filename = patterns.front().replace('*', filename);
}
filesize = data.size();
}
} else {
if (type == ToPrepareDocument) {
filename = filedialogDefaultName(qsl("image"), qsl(".png"), QString(), true);
QMimeType mimeType = QMimeDatabase().mimeTypeForName("image/png");
data = QByteArray();
{
QBuffer b(&data);
img.save(&b, "PNG");
}
filesize = data.size();
} else {
type = ToPreparePhoto; // only photo from QImage
filename = qsl("Untitled.jpg");
filesize = 0;
}
}
if ((img.isNull() && (type != ToPrepareDocument || !filesize)) || type == ToPrepareAuto || (img.isNull() && file.isEmpty() && data.isEmpty())) { // if could not decide what type
{
QMutexLocker lock(loader->toPrepareMutex());
ToPrepareMedias &list(loader->toPrepareMedias());
list.pop_front();
}
QTimer::singleShot(1, this, SLOT(prepareImages()));
emit imageFailed(id);
} else {
PreparedPhotoThumbs photoThumbs;
QVector<MTPPhotoSize> photoSizes;
MTPPhotoSize thumb(MTP_photoSizeEmpty(MTP_string("")));
MTPPhoto photo(MTP_photoEmpty(MTP_long(0)));
MTPDocument document(MTP_documentEmpty(MTP_long(0)));
QByteArray jpeg;
if (type == ToPreparePhoto) {
int32 w = img.width(), h = img.height();
QPixmap thumb = (w > 100 || h > 100) ? QPixmap::fromImage(img.scaled(100, 100, Qt::KeepAspectRatio, Qt::SmoothTransformation)) : QPixmap::fromImage(img);
photoThumbs.insert('s', thumb);
photoSizes.push_back(MTP_photoSize(MTP_string("s"), MTP_fileLocationUnavailable(MTP_long(0), MTP_int(0), MTP_long(0)), MTP_int(thumb.width()), MTP_int(thumb.height()), MTP_int(0)));
QPixmap medium = (w > 320 || h > 320) ? QPixmap::fromImage(img.scaled(320, 320, Qt::KeepAspectRatio, Qt::SmoothTransformation)) : QPixmap::fromImage(img);
photoThumbs.insert('m', medium);
photoSizes.push_back(MTP_photoSize(MTP_string("m"), MTP_fileLocationUnavailable(MTP_long(0), MTP_int(0), MTP_long(0)), MTP_int(medium.width()), MTP_int(medium.height()), MTP_int(0)));
QPixmap full = (w > 800 || h > 800) ? QPixmap::fromImage(img.scaled(800, 800, Qt::KeepAspectRatio, Qt::SmoothTransformation)) : QPixmap::fromImage(img);
photoThumbs.insert('x', full);
photoSizes.push_back(MTP_photoSize(MTP_string("x"), MTP_fileLocationUnavailable(MTP_long(0), MTP_int(0), MTP_long(0)), MTP_int(full.width()), MTP_int(full.height()), MTP_int(0)));
{
QBuffer jpegBuffer(&jpeg);
full.save(&jpegBuffer, "JPG", 87);
}
if (!filesize) filesize = jpeg.size();
photo = MTP_photo(MTP_long(id), MTP_long(0), MTP_int(user), MTP_int(unixtime()), MTP_string(""), MTP_geoPointEmpty(), MTP_vector<MTPPhotoSize>(photoSizes));
jpeg_id = id;
} else if ((type == ToPrepareVideo || type == ToPrepareDocument) && !img.isNull()) {
int32 w = img.width(), h = img.height();
QPixmap full = (w > 90 || h > 90) ? QPixmap::fromImage(img.scaled(90, 90, Qt::KeepAspectRatio, Qt::SmoothTransformation)) : QPixmap::fromImage(img);
{
QBuffer jpegBuffer(&jpeg);
full.save(&jpegBuffer, "JPG", 87);
}
photoThumbs.insert('0', full);
thumb = MTP_photoSize(MTP_string(""), MTP_fileLocationUnavailable(MTP_long(0), MTP_int(0), MTP_long(0)), MTP_int(full.width()), MTP_int(full.height()), MTP_int(0));
jpeg_id = MTP::nonce<uint64>();
}
if (type == ToPrepareDocument) {
document = MTP_document(MTP_long(id), MTP_long(0), MTP_int(MTP::authedId()), MTP_int(unixtime()), MTP_string(filename), MTP_string(mime), MTP_int(filesize), thumb, MTP_int(MTP::maindc()));
}
{
QMutexLocker lock(loader->readyMutex());
loader->readyList().push_back(ReadyLocalMedia(type, file, filename, filesize, data, id, jpeg_id, peer, photo, photoThumbs, document, jpeg));
}
{
QMutexLocker lock(loader->toPrepareMutex());
ToPrepareMedias &list(loader->toPrepareMedias());
list.pop_front();
}
QTimer::singleShot(1, this, SLOT(prepareImages()));
emit imageReady();
}
}
Archive *Archive::create(const QString &fileName, const QString &fixedMimeType, QObject *parent)
{
qCDebug(ARK) << "Going to create archive" << fileName;
qRegisterMetaType<ArchiveEntry>("ArchiveEntry");
PluginManager pluginManager;
const QMimeType mimeType = fixedMimeType.isEmpty() ? determineMimeType(fileName) : QMimeDatabase().mimeTypeForName(fixedMimeType);
const QVector<Plugin*> offers = pluginManager.preferredPluginsFor(mimeType);
if (offers.isEmpty()) {
qCCritical(ARK) << "Could not find a plugin to handle" << fileName;
return new Archive(NoPlugin, parent);
}
Archive *archive;
foreach (Plugin *plugin, offers) {
archive = create(fileName, plugin, parent);
// Use the first valid plugin, according to the priority sorting.
if (archive->isValid()) {
return archive;
}
}
