KIcon iconForContent( KMime::Content *content )
{
if ( !content->contentType( false ) )
return KIcon();
KMimeType::Ptr mimeType = KMimeType::mimeType( QString::fromLatin1( content->contentType()->mimeType() ) );
if ( mimeType.isNull() || mimeType->iconName().isEmpty() )
return KIcon();
return KIcon( mimeType->iconName() );
}
// ## where is this used?
QPixmap KFileItem::pixmap( int _size, int _state ) const
{
const QString iconName = d->m_entry.stringValue( KIO::UDSEntry::UDS_ICON_NAME );
if ( !iconName.isEmpty() )
return DesktopIcon(iconName, _size, _state);
if (!d->m_pMimeType) {
// No mimetype determined yet, go for a fast default icon
if (S_ISDIR(d->m_fileMode)) {
static const QString * defaultFolderIcon = 0;
if ( !defaultFolderIcon ) {
const KMimeType::Ptr mimeType = KMimeType::mimeType( "inode/directory" );
if ( mimeType )
defaultFolderIcon = &KGlobal::staticQString( mimeType->iconName() );
else
kWarning(7000) << "No mimetype for inode/directory could be found. Check your installation.";
}
if ( defaultFolderIcon )
return DesktopIcon( *defaultFolderIcon, _size, _state );
}
return DesktopIcon( "unknown", _size, _state );
}
KMimeType::Ptr mime;
// Use guessed mimetype if the main one hasn't been determined for sure
if ( !d->m_bMimeTypeKnown && !d->m_guessedMimeType.isEmpty() )
mime = KMimeType::mimeType( d->m_guessedMimeType );
else
mime = d->m_pMimeType;
// Support for gzipped files: extract mimetype of contained file
// See also the relevant code in overlays, which adds the zip overlay.
if ( mime->name() == "application/x-gzip" && d->m_url.fileName().endsWith( QLatin1String( ".gz" ) ) )
{
KUrl sf;
sf.setPath( d->m_url.path().left( d->m_url.path().length() - 3 ) );
//kDebug() << "subFileName=" << subFileName;
mime = KMimeType::findByUrl( sf, 0, d->m_bIsLocalUrl );
}
bool isLocalUrl;
KUrl url = mostLocalUrl(isLocalUrl);
QPixmap p = KIconLoader::global()->loadMimeTypeIcon( mime->iconName( url ), KIconLoader::Desktop, _size, _state );
//kDebug() << "finding pixmap for " << url.url() << " : " << mime->name();
if (p.isNull())
kWarning() << "Pixmap not found for mimetype " << d->m_pMimeType->name();
return p;
}
// at first, tries to find the iconname in the cache
// if not available, tries to find the pixmap for the mimetype of url
// if that fails, gets the icon for the protocol
// finally, inserts the url/icon pair into the cache
QString KonqPixmapProvider::iconNameFor( const KUrl& url )
{
QMap<KUrl,QString>::iterator it = iconMap.find( url );
QString icon;
if ( it != iconMap.end() ) {
icon = it.value();
if ( !icon.isEmpty() )
return icon;
}
if ( url.url().isEmpty() ) {
// Use the folder icon for the empty URL
const KMimeType::Ptr directoryType = KMimeType::mimeType( "inode/directory" );
if( directoryType.isNull() ) // no mimetypes installed!
return QString();
icon = directoryType->iconName();
Q_ASSERT( !icon.isEmpty() );
}
else
{
icon = KMimeType::iconNameForUrl( url );
Q_ASSERT( !icon.isEmpty() );
}
// cache the icon found for url
iconMap.insert( url, icon );
return icon;
}
bool Script::execute()
{
if (!bt::Exists(file) || action)
return false;
KMimeType::Ptr mt = KMimeType::findByPath(file);
QString name = QFileInfo(file).fileName();
action = new Kross::Action(this,name);
action->setText(name);
action->setDescription(name);
action->setFile(file);
action->setIconName(mt->iconName());
QString interpreter = Kross::Manager::self().interpreternameForFile(file);
if (interpreter.isNull())
{
delete action;
action = 0;
return false;
}
else
{
action->setInterpreter(interpreter);
Kross::Manager::self().actionCollection()->addAction(file,action);
action->trigger();
executing = true;
return true;
}
}
QString KFileItem::iconName() const
{
if (d->m_useIconNameCache && !d->m_iconName.isEmpty()) {
return d->m_iconName;
}
d->m_iconName = d->m_entry.stringValue( KIO::UDSEntry::UDS_ICON_NAME );
if (!d->m_iconName.isEmpty()) {
d->m_useIconNameCache = d->m_bMimeTypeKnown;
return d->m_iconName;
}
bool isLocalUrl;
KUrl url = mostLocalUrl(isLocalUrl);
KMimeType::Ptr mime = mimeTypePtr();
if (isLocalUrl && mime->is("application/x-desktop")) {
d->m_iconName = iconFromDesktopFile(url.toLocalFile());
if (!d->m_iconName.isEmpty()) {
d->m_useIconNameCache = d->m_bMimeTypeKnown;
return d->m_iconName;
}
}
// KDE5: handle .directory files here too, and get rid of
// KFolderMimeType and the url argument in KMimeType::iconName().
d->m_iconName = mime->iconName(url);
d->m_useIconNameCache = d->m_bMimeTypeKnown;
//kDebug() << "finding icon for" << url << ":" << d->m_iconName;
return d->m_iconName;
}
void DocumentPreviewTab::setResource(Nepomuk2::Resource & resource)
{
m_resource = resource;
ui->urlSelector->clear();
if(m_part) {
m_part->closeUrl();
}
QString specificUrl;
if(resource.isValid()) {
specificUrl = resource.property(Nepomuk2::Vocabulary::NIE::url()).toString();
if(!specificUrl.isEmpty()) {
resource = resource.property(Nepomuk2::Vocabulary::NBIB::publishedAs()).toResource();
m_resource = resource;
}
QList<Nepomuk2::Resource> fileList;
if(resource.hasType(Nepomuk2::Vocabulary::NBIB::Reference())) {
Nepomuk2::Resource publication = resource.property(Nepomuk2::Vocabulary::NBIB::publication()).toResource();
fileList = publication.property(Nepomuk2::Vocabulary::NBIB::isPublicationOf()).toResourceList();
fileList.append( publication.property(Nepomuk2::Vocabulary::NIE::links()).toResourceList() );
}
else if(resource.hasType(Nepomuk2::Vocabulary::NBIB::Publication())) {
fileList = resource.property(Nepomuk2::Vocabulary::NBIB::isPublicationOf()).toResourceList();
fileList.append( resource.property(Nepomuk2::Vocabulary::NIE::links()).toResourceList() );
}
else {
fileList.append(resource);
}
// add all DataObjects to the preview
foreach(const Nepomuk2::Resource & r, fileList) {
KUrl url = KUrl(r.property(Nepomuk2::Vocabulary::NIE::url()).toString());
KIcon icon;
QString mimetype;
if( r.hasType(Nepomuk2::Vocabulary::NFO::Website())// || r.hasType(Nepomuk2::Vocabulary::NFO::WebDataObject())
|| url.scheme() == QLatin1String("http")) {
QString favIcon = KMimeType::favIconForUrl(url);
if(favIcon.isEmpty()) {
favIcon = QLatin1String("text-html");
}
icon = KIcon(favIcon);
mimetype = QLatin1String("text/html");
}
else {
KMimeType::Ptr mimeTypePtr = KMimeType::findByUrl(url);
icon = KIcon(mimeTypePtr->iconName());
mimetype = mimeTypePtr->name();
}
ui->urlSelector->addItem(icon,url.url(),QVariant(mimetype));
}
static QPixmap icon( KMimeType::Ptr mimeType, const QString &uri,
bool binary = false )
{
QString iconStr = mimeType->iconName( uri );
QStringList overlays;
if ( !uri.isEmpty() && !binary ) {
overlays << "emblem-link";
}
return KIconLoader::global()->loadIcon( iconStr, KIconLoader::Desktop, 0,
KIconLoader::DefaultState,
overlays );
}
bool ArkViewer::viewInInternalViewer(const QString& fileName, const KMimeType::Ptr& mimeType)
{
const KUrl fileUrl(fileName);
setCaption(fileUrl.fileName());
restoreDialogSize(KGlobal::config()->group("Viewer"));
QFrame *header = new QFrame(m_widget);
QHBoxLayout *headerLayout = new QHBoxLayout(header);
QLabel *iconLabel = new QLabel(header);
headerLayout->addWidget(iconLabel);
iconLabel->setPixmap(KIconLoader::global()->loadMimeTypeIcon(mimeType->iconName(), KIconLoader::Desktop));
iconLabel->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Minimum);
KVBox *headerRight = new KVBox(header);
headerLayout->addWidget(headerRight);
new QLabel(QString(QLatin1String( "<qt><b>%1</b></qt>" ))
.arg(fileUrl.fileName()), headerRight
);
new QLabel(mimeType->comment(), headerRight);
header->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Maximum);
m_part = KMimeTypeTrader::self()->createPartInstanceFromQuery<KParts::ReadOnlyPart>(mimeType->name(),
m_widget,
this);
if (!m_part.data()) {
return false;
}
if (m_part.data()->browserExtension()) {
connect(m_part.data()->browserExtension(),
SIGNAL(openUrlRequestDelayed(KUrl,KParts::OpenUrlArguments,KParts::BrowserArguments)),
SLOT(slotOpenUrlRequestDelayed(KUrl,KParts::OpenUrlArguments,KParts::BrowserArguments)));
}
m_part.data()->openUrl(fileUrl);
return true;
}
void KMMsgPartDialog::slotMimeTypeChanged( const QString & mimeType ) {
// message subparts MUST have 7bit or 8bit encoding...
#if 0
// ...but until KMail can recode 8bit messages on attach, so that
// they can be signed, we can't enforce this :-(
if ( mimeType.startsWith("message/") ) {
setEncoding( SevenBit );
mEncoding->setEnabled( false );
} else {
mEncoding->setEnabled( !mReadOnly );
}
#endif
// find a mimetype icon:
KMimeType::Ptr mt = KMimeType::mimeType( mimeType, KMimeType::ResolveAliases );
if ( !mt.isNull() )
mIcon->setPixmap( KIconLoader::global()->loadMimeTypeIcon( mt->iconName(),
KIconLoader::Desktop ) );
else
mIcon->setPixmap( DesktopIcon("unknown") );
}
void Nepomuk::QueryClientWrapper::slotNewEntries(const QList<Nepomuk::Query::Result>& results)
{
QList<Plasma::QueryMatch> matches;
foreach(const Query::Result& result, results) {
Plasma::QueryMatch match(m_runner);
match.setType(Plasma::QueryMatch::PossibleMatch);
match.setRelevance(normalizeScore(result.score()));
Nepomuk::Resource res = result.resource();
QString type;
QString iconName;
KMimeType::Ptr mimetype;
if (res.hasProperty(Nepomuk::Vocabulary::NIE::mimeType())) {
mimetype = KMimeType::mimeType(res.property(Nepomuk::Vocabulary::NIE::mimeType()).toString());
}
if (!mimetype && res.isFile() && res.toFile().url().isLocalFile()) {
const KUrl url(res.toFile().url());
mimetype = KMimeType::findByUrl(url);
}
if (mimetype) {
type = mimetype->comment();
iconName = mimetype->iconName();
}
if (type.isEmpty() ) {
type = Nepomuk::Types::Class(res.resourceType()).label();
iconName = res.genericIcon();
}
match.setText(res.genericLabel());
match.setSubtext(type);
match.setIcon(KIcon(iconName.isEmpty() ? QString::fromLatin1("nepomuk") : iconName));
match.setData(qVariantFromValue(res));
match.setId(KUrl(res.resourceUri()).url());
matches << match;
}
void KGetLinkView::showLinks( const QList<QString>& links )
{
QStandardItemModel *model = new QStandardItemModel(0, 5, this);
model->setHeaderData(0, Qt::Horizontal, i18n("Auxiliary header"));
model->setHeaderData(1, Qt::Horizontal, i18n("File Name"));
model->setHeaderData(2, Qt::Horizontal, i18n("Description"));
model->setHeaderData(3, Qt::Horizontal, i18nc("list header: type of file", "File Type"));
model->setHeaderData(4, Qt::Horizontal, i18n("Location (URL)"));
foreach (const QString &linkitem, links)
{
KUrl url(linkitem);
QString file = url.fileName();
if (file.isEmpty())
{
file = QString(url.host());
}
KMimeType::Ptr mt = KMimeType::findByUrl(linkitem, 0, true, true);
QList<QStandardItem*> items;
QStandardItem *item = new QStandardItem(file);
item->setIcon(KIcon(mt->iconName()));
item->setCheckable(true);
item->setData(QVariant(url.fileName()), Qt::DisplayRole);
item->setData(QVariant(mt->name()), Qt::UserRole); // used for filtering DownloadFilterType
items << new QStandardItem(QString::number(model->rowCount()));
items << item;
items << new QStandardItem();
items << new QStandardItem(mt->comment());
items << new QStandardItem(url.prettyUrl());
model->insertRow(model->rowCount(), items);
}
LinkItem::LinkItem( DOM::Element link )
: m_valid( false )
{
DOM::NamedNodeMap attrs = link.attributes();
DOM::Node href = attrs.getNamedItem( "href" );
// Load source address of images too
DOM::Node src = attrs.getNamedItem( "src" );
if ( href.nodeValue().string().isEmpty() && !src.nodeValue().string().isEmpty() )
href = src;
// qDebug("*** href: %s", href.nodeValue().string().latin1() );
QString urlString = link.ownerDocument().completeURL( href.nodeValue() ).string();
if ( urlString.isEmpty() )
return;
url = KUrl( urlString );
if ( !KProtocolManager::supportsReading( url ) )
return;
// somehow getElementsByTagName("#text") doesn't work :(
DOM::NodeList children = link.childNodes();
for ( uint i = 0; i < children.length(); i++ )
{
DOM::Node node = children.item( i );
if ( node.nodeType() == DOM::Node::TEXT_NODE )
text.append( node.nodeValue().string() );
}
// force "local file" mimetype determination
KMimeType::Ptr mt = KMimeType::findByUrl( url, 0, true, true);
icon = mt->iconName();
mimeType = mt->comment();
m_valid = true;
}
KoDocumentInfoDlg::KoDocumentInfoDlg(QWidget* parent, KoDocumentInfo* docInfo, KoDocumentRdf* docRdf)
: KPageDialog(parent)
, d(new KoDocumentInfoDlgPrivate)
{
d->m_info = docInfo;
d->m_rdf = docRdf;
setCaption(i18n("Document Information"));
setInitialSize(QSize(500, 500));
setFaceType(KPageDialog::List);
setButtons(KDialog::Ok | KDialog::Cancel);
setDefaultButton(KDialog::Ok);
d->m_aboutUi = new Ui::KoDocumentInfoAboutWidget();
QWidget *infodlg = new QWidget();
d->m_aboutUi->setupUi(infodlg);
if (!KoEncryptionChecker::isEncryptionSupported()) {
d->m_aboutUi->lblEncryptedDesc->setVisible(false);
d->m_aboutUi->lblEncrypted->setVisible(false);
d->m_aboutUi->pbEncrypt->setVisible(false);
d->m_aboutUi->lblEncryptedPic->setVisible(false);
}
KPageWidgetItem *page = new KPageWidgetItem(infodlg, i18n("General"));
page->setHeader(i18n("General"));
// Ugly hack, the mimetype should be a parameter, instead
KoDocument* doc = dynamic_cast< KoDocument* >(d->m_info->parent());
if (doc) {
KMimeType::Ptr mime = KMimeType::mimeType(doc->mimeType());
if (! mime)
mime = KMimeType::defaultMimeTypePtr();
page->setIcon(KIcon(KIconLoader::global()->loadMimeTypeIcon(mime->iconName(), KIconLoader::Desktop, 48)));
}
addPage(page);
d->m_pages.append(page);
initAboutTab();
d->m_authorUi = new Ui::KoDocumentInfoAuthorWidget();
QWidget *authordlg = new QWidget();
d->m_authorUi->setupUi(authordlg);
page = new KPageWidgetItem(authordlg, i18n("Author"));
page->setHeader(i18n("Author"));
page->setIcon(KIcon("user-identity"));
addPage(page);
d->m_pages.append(page);
initAuthorTab();
// Saving encryption implies saving the document, this is done after closing the dialog
connect(this, SIGNAL(hidden()), this, SLOT(slotSaveEncryption()));
if (d->m_rdf) {
d->m_rdfEditWidget = 0;
#ifdef SHOULD_BUILD_RDF
d->m_rdfEditWidget = new KoDocumentRdfEditWidget(this, d->m_rdf);
page = new KPageWidgetItem(d->m_rdfEditWidget->widget(), i18n("Rdf"));
page->setHeader(i18n("Rdf"));
page->setIcon(KIcon("text-rdf"));
addPage(page);
d->m_pages.append(page);
#endif
}
}
PropertiesDialog::PropertiesDialog(QWidget *parent, Okular::Document *doc)
: KPageDialog( parent ), m_document( doc ), m_fontPage( 0 ),
m_fontModel( 0 ), m_fontInfo( 0 ), m_fontProgressBar( 0 ),
m_fontScanStarted( false )
{
setFaceType( Tabbed );
setCaption( i18n( "Unknown File" ) );
setButtons( Ok );
// PROPERTIES
QFrame *page = new QFrame();
KPageWidgetItem *item = addPage( page, i18n( "&Properties" ) );
item->setIcon( KIcon( "document-properties" ) );
// get document info
const Okular::DocumentInfo info = doc->documentInfo();
QFormLayout *layout = new QFormLayout( page );
// mime name based on mimetype id
QString mimeName = info.get( Okular::DocumentInfo::MimeType ).section( '/', -1 ).toUpper();
setCaption( i18n( "%1 Properties", mimeName ) );
int valMaxWidth = 100;
/* obtains the properties list, conveniently ordered */
QStringList orderedProperties;
orderedProperties << Okular::DocumentInfo::getKeyString( Okular::DocumentInfo::FilePath )
<< Okular::DocumentInfo::getKeyString( Okular::DocumentInfo::PagesSize )
<< Okular::DocumentInfo::getKeyString( Okular::DocumentInfo::DocumentSize );
for (Okular::DocumentInfo::Key ks = Okular::DocumentInfo::Title;
ks <= Okular::DocumentInfo::Keywords;
ks = Okular::DocumentInfo::Key( ks+1 ) )
{
orderedProperties << Okular::DocumentInfo::getKeyString( ks );
}
foreach( const QString &ks, info.keys()) {
if ( !orderedProperties.contains( ks ) ) {
orderedProperties << ks;
}
}
for ( QStringList::Iterator it = orderedProperties.begin();
it != orderedProperties.end();
++it )
{
const QString key = *it;
const QString titleString = info.getKeyTitle( key );
const QString valueString = info.get( key );
if ( titleString.isNull() || valueString.isNull() )
continue;
// create labels and layout them
QWidget *value = NULL;
if ( key == Okular::DocumentInfo::getKeyString( Okular::DocumentInfo::MimeType ) ) {
/// for mime type fields, show icon as well
value = new QWidget( page );
/// place icon left of mime type's name
QHBoxLayout *hboxLayout = new QHBoxLayout( value );
hboxLayout->setMargin( 0 );
/// retrieve icon and place it in a QLabel
KMimeType::Ptr mimeType = KMimeType::mimeType( valueString );
KSqueezedTextLabel *squeezed;
if (!mimeType.isNull()) {
/// retrieve icon and place it in a QLabel
QLabel *pixmapLabel = new QLabel( value );
hboxLayout->addWidget( pixmapLabel, 0 );
pixmapLabel->setPixmap( KIconLoader::global()->loadMimeTypeIcon( mimeType->iconName(), KIconLoader::Small ) );
/// mime type's name and label
squeezed = new KSqueezedTextLabel( i18nc( "mimetype information, example: \"PDF Document (application/pdf)\"", "%1 (%2)", mimeType->comment(), valueString ), value );
} else {
/// only mime type name
squeezed = new KSqueezedTextLabel( valueString, value );
}
squeezed->setTextInteractionFlags( Qt::TextSelectableByMouse );
hboxLayout->addWidget( squeezed, 1 );
} else {
/// default for any other document information
KSqueezedTextLabel *label = new KSqueezedTextLabel( valueString, page );
label->setTextInteractionFlags( Qt::TextSelectableByMouse );
value = label;
}
layout->addRow( new QLabel( i18n( "%1:", titleString ) ), value);
// refine maximum width of 'value' labels
valMaxWidth = qMax( valMaxWidth, fontMetrics().width( valueString ) );
}
// FONTS
QVBoxLayout *page2Layout = 0;
if ( doc->canProvideFontInformation() ) {
// create fonts tab and layout it
QFrame *page2 = new QFrame();
m_fontPage = addPage(page2, i18n("&Fonts"));
m_fontPage->setIcon( KIcon( "preferences-desktop-font" ) );
page2Layout = new QVBoxLayout(page2);
page2Layout->setMargin(marginHint());
page2Layout->setSpacing(spacingHint());
// add a tree view
QTreeView *view = new QTreeView(page2);
view->setContextMenuPolicy(Qt::CustomContextMenu);
connect(view, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(showFontsMenu(QPoint)));
page2Layout->addWidget(view);
view->setRootIsDecorated(false);
view->setAlternatingRowColors(true);
view->setSortingEnabled( true );
// creating a proxy model so we can sort the data
QSortFilterProxyModel *proxymodel = new QSortFilterProxyModel(view);
proxymodel->setDynamicSortFilter( true );
proxymodel->setSortCaseSensitivity( Qt::CaseInsensitive );
m_fontModel = new FontsListModel(view);
proxymodel->setSourceModel(m_fontModel);
view->setModel(proxymodel);
view->sortByColumn( 0, Qt::AscendingOrder );
m_fontInfo = new QLabel( this );
page2Layout->addWidget( m_fontInfo );
m_fontInfo->setText( i18n( "Reading font information..." ) );
m_fontInfo->hide();
m_fontProgressBar = new QProgressBar( this );
page2Layout->addWidget( m_fontProgressBar );
m_fontProgressBar->setRange( 0, 100 );
m_fontProgressBar->setValue( 0 );
m_fontProgressBar->hide();
}
// current width: left columnt + right column + dialog borders
int width = layout->minimumSize().width() + valMaxWidth + 2 * marginHint() + spacingHint() + 30;
if ( page2Layout )
width = qMax( width, page2Layout->sizeHint().width() + marginHint() + spacingHint() + 31 );
// stay inside the 2/3 of the screen width
QRect screenContainer = KGlobalSettings::desktopGeometry( this );
width = qMin( width, 2*screenContainer.width()/3 );
resize(width, 1);
connect( pageWidget(), SIGNAL(currentPageChanged(KPageWidgetItem*,KPageWidgetItem*)),
this, SLOT(pageChanged(KPageWidgetItem*,KPageWidgetItem*)) );
}
