#include "kfileitemlistwidget.h"
+#include "kfileitemclipboard_p.h"
#include "kfileitemmodel.h"
#include "kitemlistview.h"
#include "kpixmapmodifier_p.h"
#include <QFontMetricsF>
#include <QGraphicsSceneResizeEvent>
#include <QPainter>
+#include <QStyleOption>
#include <QTextLayout>
#include <QTextLine>
-//#define KFILEITEMLISTWIDGET_DEBUG
+// #define KFILEITEMLISTWIDGET_DEBUG
KFileItemListWidget::KFileItemListWidget(QGraphicsItem* parent) :
KItemListWidget(parent),
- m_isDir(false),
+ m_isCut(false),
+ m_isHidden(false),
+ m_isExpandable(false),
m_dirtyLayout(true),
m_dirtyContent(true),
m_dirtyContentRoles(),
m_pixmapPos(),
m_pixmap(),
m_scaledPixmapSize(),
- m_hoverPixmapRect(),
+ m_iconRect(),
m_hoverPixmap(),
m_textPos(),
m_text(),
- m_textsBoundingRect(),
+ m_textRect(),
m_sortedVisibleRoles(),
m_expansionArea(),
- m_additionalInfoTextColor()
+ m_customTextColor(),
+ m_additionalInfoTextColor(),
+ m_overlay()
{
for (int i = 0; i < TextIdCount; ++i) {
m_text[i].setTextFormat(Qt::PlainText);
if (m_layout != layout) {
m_layout = layout;
m_dirtyLayout = true;
+ updateAdditionalInfoTextColor();
update();
}
}
void KFileItemListWidget::paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget)
{
- KItemListWidget::paint(painter, option, widget);
-
- painter->setRenderHint(QPainter::Antialiasing);
+ const_cast<KFileItemListWidget*>(this)->triggerCacheRefreshing();
- if (m_dirtyContent || m_dirtyLayout) {
- const_cast<KFileItemListWidget*>(this)->updateCache();
- }
+ KItemListWidget::paint(painter, option, widget);
- if (m_isDir && !m_expansionArea.isEmpty()) {
+ // Draw expansion toggle '>' or 'V'
+ if (m_isExpandable && !m_expansionArea.isEmpty()) {
QStyleOption arrowOption;
arrowOption.rect = m_expansionArea.toRect();
const QStyle::PrimitiveElement arrow = data()["isExpanded"].toBool()
style()->drawPrimitive(arrow, &arrowOption, painter);
}
- const bool isHovered = (hoverOpacity() > 0.0);
-
const KItemListStyleOption& itemListStyleOption = styleOption();
- if (isHovered) {
+ if (isHovered()) {
// Blend the unhovered and hovered pixmap if the hovering
// animation is ongoing
if (hoverOpacity() < 1.0) {
const qreal opacity = painter->opacity();
painter->setOpacity(hoverOpacity() * opacity);
drawPixmap(painter, m_hoverPixmap);
-
- // Draw the hover background for the text
- QRectF textsBoundingRect = m_textsBoundingRect;
- const qreal marginDiff = itemListStyleOption.margin / 2;
- textsBoundingRect.adjust(marginDiff, marginDiff, -marginDiff, -marginDiff);
- painter->setOpacity(hoverOpacity() * opacity * 0.1);
- painter->setPen(Qt::NoPen);
- painter->setBrush(itemListStyleOption.palette.text());
- painter->drawRoundedRect(textsBoundingRect, 4, 4);
-
painter->setOpacity(opacity);
} else {
drawPixmap(painter, m_pixmap);
}
painter->setFont(itemListStyleOption.font);
- painter->setPen(itemListStyleOption.palette.text().color());
+ painter->setPen(textColor());
painter->drawStaticText(m_textPos[Name], m_text[Name]);
+ bool clipAdditionalInfoBounds = false;
+ if (m_layout == DetailsLayout) {
+ // Prevent a possible overlapping of the additional-information texts
+ // with the icon. This can happen if the user has minimized the width
+ // of the name-column to a very small value.
+ const qreal minX = m_pixmapPos.x() + m_pixmap.width() + 4 * itemListStyleOption.padding;
+ if (m_textPos[Name + 1].x() < minX) {
+ clipAdditionalInfoBounds = true;
+ painter->save();
+ painter->setClipRect(minX, 0, size().width() - minX, size().height(), Qt::IntersectClip);
+ }
+ }
+
painter->setPen(m_additionalInfoTextColor);
+ painter->setFont(itemListStyleOption.font);
for (int i = Name + 1; i < TextIdCount; ++i) {
painter->drawStaticText(m_textPos[i], m_text[i]);
}
+ if (clipAdditionalInfoBounds) {
+ painter->restore();
+ }
+
#ifdef KFILEITEMLISTWIDGET_DEBUG
- painter->setPen(Qt::red);
painter->setBrush(Qt::NoBrush);
+ painter->setPen(Qt::green);
+ painter->drawRect(m_iconRect);
+
+ painter->setPen(Qt::red);
painter->drawText(QPointF(0, itemListStyleOption.fontMetrics.height()), QString::number(index()));
painter->drawRect(rect());
#endif
}
-bool KFileItemListWidget::contains(const QPointF& point) const
+QRectF KFileItemListWidget::iconRect() const
{
- return KItemListWidget::contains(point) || m_textsBoundingRect.contains(point);
+ const_cast<KFileItemListWidget*>(this)->triggerCacheRefreshing();
+ return m_iconRect;
}
-QRectF KFileItemListWidget::hoverBoundingRect() const
+QRectF KFileItemListWidget::textRect() const
{
- QRectF bounds = m_hoverPixmapRect;
- const qreal margin = styleOption().margin;
- bounds.adjust(-margin, -margin, margin, margin);
- return bounds;
+ const_cast<KFileItemListWidget*>(this)->triggerCacheRefreshing();
+ return m_textRect;
}
QRectF KFileItemListWidget::expansionToggleRect() const
{
- return m_isDir ? m_expansionArea : QRectF();
+ const_cast<KFileItemListWidget*>(this)->triggerCacheRefreshing();
+ return m_isExpandable ? m_expansionArea : QRectF();
+}
+
+QRectF KFileItemListWidget::selectionToggleRect() const
+{
+ const_cast<KFileItemListWidget*>(this)->triggerCacheRefreshing();
+
+ const int iconHeight = styleOption().iconSize;
+
+ int toggleSize = KIconLoader::SizeSmall;
+ if (iconHeight >= KIconLoader::SizeEnormous) {
+ toggleSize = KIconLoader::SizeMedium;
+ } else if (iconHeight >= KIconLoader::SizeLarge) {
+ toggleSize = KIconLoader::SizeSmallMedium;
+ }
+
+ QPointF pos = iconRect().topLeft();
+
+ // If the selection toggle has a very small distance to the
+ // widget borders, the size of the selection toggle will get
+ // increased to prevent an accidental clicking of the item
+ // when trying to hit the toggle.
+ const int widgetHeight = size().height();
+ const int widgetWidth = size().width();
+ const int minMargin = 2;
+
+ if (toggleSize + minMargin * 2 >= widgetHeight) {
+ pos.rx() -= (widgetHeight - toggleSize) / 2;
+ toggleSize = widgetHeight;
+ pos.setY(0);
+ }
+ if (toggleSize + minMargin * 2 >= widgetWidth) {
+ pos.ry() -= (widgetWidth - toggleSize) / 2;
+ toggleSize = widgetWidth;
+ pos.setX(0);
+ }
+
+ return QRectF(pos, QSizeF(toggleSize, toggleSize));
+}
+
+QString KFileItemListWidget::roleText(const QByteArray& role, const QHash<QByteArray, QVariant>& values)
+{
+ QString text;
+ const QVariant roleValue = values.value(role);
+
+ switch (roleTextId(role)) {
+ case Name:
+ case Permissions:
+ case Owner:
+ case Group:
+ case Type:
+ case Destination:
+ case Path:
+ text = roleValue.toString();
+ break;
+
+ case Size: {
+ if (values.value("isDir").toBool()) {
+ // The item represents a directory. Show the number of sub directories
+ // instead of the file size of the directory.
+ if (!roleValue.isNull()) {
+ const int count = roleValue.toInt();
+ if (count < 0) {
+ text = i18nc("@item:intable", "Unknown");
+ } else {
+ text = i18ncp("@item:intable", "%1 item", "%1 items", count);
+ }
+ }
+ } else {
+ // Show the size in kilobytes (always round up)
+ const KLocale* locale = KGlobal::locale();
+ const int roundInc = (locale->binaryUnitDialect() == KLocale::MetricBinaryDialect) ? 499 : 511;
+ const KIO::filesize_t size = roleValue.value<KIO::filesize_t>() + roundInc;
+ text = locale->formatByteSize(size, 0, KLocale::DefaultBinaryDialect, KLocale::UnitKiloByte);
+ }
+ break;
+ }
+
+ case Date: {
+ const QDateTime dateTime = roleValue.toDateTime();
+ text = KGlobal::locale()->formatDateTime(dateTime);
+ break;
+ }
+
+ default:
+ Q_ASSERT(false);
+ break;
+ }
+
+ return text;
+}
+
+void KFileItemListWidget::invalidateCache()
+{
+ m_dirtyLayout = true;
+ m_dirtyContent = true;
+}
+
+void KFileItemListWidget::refreshCache()
+{
+}
+
+void KFileItemListWidget::setTextColor(const QColor& color)
+{
+ if (color != m_customTextColor) {
+ m_customTextColor = color;
+ updateAdditionalInfoTextColor();
+ update();
+ }
+}
+
+QColor KFileItemListWidget::textColor() const
+{
+ if (m_customTextColor.isValid() && !isSelected()) {
+ return m_customTextColor;
+ }
+
+ const QPalette::ColorGroup group = isActiveWindow() ? QPalette::Active : QPalette::Inactive;
+ const QPalette::ColorRole role = isSelected() ? QPalette::HighlightedText : QPalette::Text;
+ return styleOption().palette.brush(group, role).color();
+}
+
+void KFileItemListWidget::setOverlay(const QPixmap& overlay)
+{
+ m_overlay = overlay;
+ m_dirtyContent = true;
+ update();
+}
+
+QPixmap KFileItemListWidget::overlay() const
+{
+ return m_overlay;
}
void KFileItemListWidget::dataChanged(const QHash<QByteArray, QVariant>& current,
QSet<QByteArray> dirtyRoles;
if (roles.isEmpty()) {
- dirtyRoles = visibleRoles().keys().toSet();
+ dirtyRoles = visibleRoles().toSet();
dirtyRoles.insert("iconPixmap");
dirtyRoles.insert("iconName");
} else {
}
}
-void KFileItemListWidget::visibleRolesChanged(const QHash<QByteArray, int>& current,
- const QHash<QByteArray, int>& previous)
+void KFileItemListWidget::visibleRolesChanged(const QList<QByteArray>& current,
+ const QList<QByteArray>& previous)
{
KItemListWidget::visibleRolesChanged(current, previous);
+ m_sortedVisibleRoles = current;
m_dirtyLayout = true;
-
- // Cache the roles sorted into m_sortedVisibleRoles:
- const int visibleRolesCount = current.count();
- m_sortedVisibleRoles.clear();
- m_sortedVisibleRoles.reserve(visibleRolesCount);
- for (int i = 0; i < visibleRolesCount; ++i) {
- m_sortedVisibleRoles.append(QByteArray());
- }
-
- QHashIterator<QByteArray, int> it(current);
- while (it.hasNext()) {
- it.next();
-
- const int index = it.value();
- if (index < 0 || index >= visibleRolesCount || !m_sortedVisibleRoles.at(index).isEmpty()) {
- kWarning() << "The visible roles have an invalid sort order.";
- break;
- }
-
- const QByteArray& role = it.key();
- m_sortedVisibleRoles[index] = role;
- }
}
void KFileItemListWidget::visibleRolesSizesChanged(const QHash<QByteArray, QSizeF>& current,
const KItemListStyleOption& previous)
{
KItemListWidget::styleOptionChanged(current, previous);
+ updateAdditionalInfoTextColor();
+ m_dirtyLayout = true;
+}
- // For the color of the additional info the inactive text color
- // is not used as this might lead to unreadable text for some color schemes. Instead
- // the text color is slightly mixed with the background color.
- const QColor c1 = current.palette.text().color();
- const QColor c2 = current.palette.background().color();
- const int p1 = 70;
- const int p2 = 100 - p1;
- m_additionalInfoTextColor = QColor((c1.red() * p1 + c2.red() * p2) / 100,
- (c1.green() * p1 + c2.green() * p2) / 100,
- (c1.blue() * p1 + c2.blue() * p2) / 100);
-
+void KFileItemListWidget::hoveredChanged(bool hovered)
+{
+ Q_UNUSED(hovered);
m_dirtyLayout = true;
}
+void KFileItemListWidget::selectedChanged(bool selected)
+{
+ Q_UNUSED(selected);
+ updateAdditionalInfoTextColor();
+}
+
void KFileItemListWidget::resizeEvent(QGraphicsSceneResizeEvent* event)
{
KItemListWidget::resizeEvent(event);
m_dirtyLayout = true;
}
-void KFileItemListWidget::updateCache()
+void KFileItemListWidget::showEvent(QShowEvent* event)
+{
+ KItemListWidget::showEvent(event);
+
+ // Listen to changes of the clipboard to mark the item as cut/uncut
+ KFileItemClipboard* clipboard = KFileItemClipboard::instance();
+
+ const KUrl itemUrl = data().value("url").value<KUrl>();
+ m_isCut = clipboard->isCut(itemUrl);
+
+ connect(clipboard, SIGNAL(cutItemsChanged()),
+ this, SLOT(slotCutItemsChanged()));
+}
+
+void KFileItemListWidget::hideEvent(QHideEvent* event)
+{
+ disconnect(KFileItemClipboard::instance(), SIGNAL(cutItemsChanged()),
+ this, SLOT(slotCutItemsChanged()));
+
+ KItemListWidget::hideEvent(event);
+}
+
+void KFileItemListWidget::slotCutItemsChanged()
+{
+ const KUrl itemUrl = data().value("url").value<KUrl>();
+ const bool isCut = KFileItemClipboard::instance()->isCut(itemUrl);
+ if (m_isCut != isCut) {
+ m_isCut = isCut;
+ m_pixmap = QPixmap();
+ m_dirtyContent = true;
+ update();
+ }
+}
+
+void KFileItemListWidget::triggerCacheRefreshing()
{
- if (index() < 0) {
+ if ((!m_dirtyContent && !m_dirtyLayout) || index() < 0) {
return;
}
- m_isDir = data()["isDir"].toBool();
+ refreshCache();
+
+ const QHash<QByteArray, QVariant> values = data();
+ m_isExpandable = values["isExpandable"].toBool();
+ m_isHidden = values["name"].toString().startsWith(QLatin1Char('.'));
updateExpansionArea();
updateTextsCache();
Q_ASSERT(values.contains("expansionLevel"));
const KItemListStyleOption& option = styleOption();
const int expansionLevel = values.value("expansionLevel", 0).toInt();
-
- const qreal widgetHeight = size().height();
- const qreal expansionLevelSize = KIconLoader::SizeSmall;
- const qreal x = option.margin + expansionLevel * widgetHeight;
- const qreal y = (widgetHeight - expansionLevelSize) / 2;
- m_expansionArea = QRectF(x, y, expansionLevelSize, expansionLevelSize);
- } else {
- m_expansionArea = QRectF();
+ if (expansionLevel >= 0) {
+ const qreal widgetHeight = size().height();
+ const qreal expansionLevelSize = KIconLoader::SizeSmall;
+ const qreal x = option.padding + expansionLevel * widgetHeight;
+ const qreal y = (widgetHeight - expansionLevelSize) / 2;
+ m_expansionArea = QRectF(x, y, expansionLevelSize, expansionLevelSize);
+ return;
+ }
}
+
+ m_expansionArea = QRectF();
}
void KFileItemListWidget::updatePixmapCache()
// Precondition: Requires already updated m_textPos values to calculate
// the remaining height when the alignment is vertical.
+ const QSizeF widgetSize = size();
const bool iconOnTop = (m_layout == IconsLayout);
const KItemListStyleOption& option = styleOption();
- const int iconHeight = option.iconSize;
+ const qreal padding = option.padding;
- const QHash<QByteArray, QVariant> values = data();
- const QSizeF widgetSize = size();
+ const int maxIconWidth = iconOnTop ? widgetSize.width() - 2 * padding : option.iconSize;
+ const int maxIconHeight = option.iconSize;
- int scaledIconHeight = 0;
- if (iconOnTop) {
- scaledIconHeight = static_cast<int>(m_textPos[Name].y() - 3 * option.margin);
- } else {
- const int textRowsCount = (m_layout == CompactLayout) ? visibleRoles().count() : 1;
- const qreal requiredTextHeight = textRowsCount * option.fontMetrics.height();
- scaledIconHeight = (requiredTextHeight < iconHeight) ? widgetSize.height() - 2 * option.margin : iconHeight;
- }
+ const QHash<QByteArray, QVariant> values = data();
- bool updatePixmap = (iconHeight != m_pixmap.height());
+ bool updatePixmap = (m_pixmap.width() != maxIconWidth || m_pixmap.height() != maxIconHeight);
if (!updatePixmap && m_dirtyContent) {
updatePixmap = m_dirtyContentRoles.isEmpty()
|| m_dirtyContentRoles.contains("iconPixmap")
- || m_dirtyContentRoles.contains("iconName");
+ || m_dirtyContentRoles.contains("iconName")
+ || m_dirtyContentRoles.contains("iconOverlays");
}
if (updatePixmap) {
// use a generic icon as fallback
iconName = QLatin1String("unknown");
}
- m_pixmap = pixmapForIcon(iconName, iconHeight);
- m_hoverPixmapRect.setSize(m_pixmap.size());
- } else if (m_pixmap.size() != QSize(iconHeight, iconHeight)) {
+ m_pixmap = pixmapForIcon(iconName, maxIconHeight);
+ } else if (m_pixmap.width() != maxIconWidth || m_pixmap.height() != maxIconHeight) {
// A custom pixmap has been applied. Assure that the pixmap
- // is scaled to the available size.
- const bool scale = m_pixmap.width() > iconHeight || m_pixmap.height() > iconHeight ||
- (m_pixmap.width() < iconHeight && m_pixmap.height() < iconHeight);
- if (scale) {
- KPixmapModifier::scale(m_pixmap, QSize(iconHeight, iconHeight));
- }
- m_hoverPixmapRect.setSize(m_pixmap.size());
-
- // To simplify the handling of scaling the original pixmap
- // will be embedded into a square pixmap.
- QPixmap squarePixmap(iconHeight, iconHeight);
- squarePixmap.fill(Qt::transparent);
-
- QPainter painter(&squarePixmap);
- if (iconOnTop) {
- const int x = (iconHeight - m_pixmap.width()) / 2; // Center horizontally
- const int y = iconHeight - m_pixmap.height(); // Align on bottom
- painter.drawPixmap(x, y, m_pixmap);
- } else {
- const int x = iconHeight - m_pixmap.width(); // Align right
- const int y = (iconHeight - m_pixmap.height()) / 2; // Center vertically
- painter.drawPixmap(x, y, m_pixmap);
+ // is scaled to the maximum available size.
+ KPixmapModifier::scale(m_pixmap, QSize(maxIconWidth, maxIconHeight));
+ }
+
+ const QStringList overlays = values["iconOverlays"].toStringList();
+
+ // Strangely KFileItem::overlays() returns empty string-values, so
+ // we need to check first whether an overlay must be drawn at all.
+ // It is more efficient to do it here, as KIconLoader::drawOverlays()
+ // assumes that an overlay will be drawn and has some additional
+ // setup time.
+ foreach (const QString& overlay, overlays) {
+ if (!overlay.isEmpty()) {
+ // There is at least one overlay, draw all overlays above m_pixmap
+ // and cancel the check
+ KIconLoader::global()->drawOverlays(overlays, m_pixmap, KIconLoader::Desktop);
+ break;
}
+ }
- m_pixmap = squarePixmap;
- } else {
- m_hoverPixmapRect.setSize(m_pixmap.size());
+ if (m_isCut) {
+ applyCutEffect(m_pixmap);
}
- Q_ASSERT(m_pixmap.height() == iconHeight);
+ if (m_isHidden) {
+ applyHiddenEffect(m_pixmap);
+ }
}
- m_scaledPixmapSize = QSize(scaledIconHeight, scaledIconHeight);
+ if (!m_overlay.isNull()) {
+ QPainter painter(&m_pixmap);
+ painter.drawPixmap(0, m_pixmap.height() - m_overlay.height(), m_overlay);
+ }
+ int scaledIconSize = 0;
if (iconOnTop) {
- m_pixmapPos.setX((widgetSize.width() - m_scaledPixmapSize.width()) / 2);
+ scaledIconSize = static_cast<int>(m_textPos[Name].y() - 2 * padding);
} else {
- m_pixmapPos.setX(m_textPos[Name].x() - 2 * option.margin - scaledIconHeight);
+ const int textRowsCount = (m_layout == CompactLayout) ? visibleRoles().count() : 1;
+ const qreal requiredTextHeight = textRowsCount * option.fontMetrics.height();
+ scaledIconSize = (requiredTextHeight < maxIconHeight) ?
+ widgetSize.height() - 2 * padding : maxIconHeight;
}
- m_pixmapPos.setY(option.margin);
- // Center the hover rectangle horizontally and align it on bottom
- const qreal x = m_pixmapPos.x() + (m_scaledPixmapSize.width() - m_hoverPixmapRect.width()) / 2.0;
- const qreal y = m_pixmapPos.y() + m_scaledPixmapSize.height() - m_hoverPixmapRect.height();
- m_hoverPixmapRect.moveTopLeft(QPointF(x, y));
+ const int maxScaledIconWidth = iconOnTop ? widgetSize.width() - 2 * padding : scaledIconSize;
+ const int maxScaledIconHeight = scaledIconSize;
+
+ m_scaledPixmapSize = m_pixmap.size();
+ m_scaledPixmapSize.scale(maxScaledIconWidth, maxScaledIconHeight, Qt::KeepAspectRatio);
+
+ if (iconOnTop) {
+ // Center horizontally and align on bottom within the icon-area
+ m_pixmapPos.setX((widgetSize.width() - m_scaledPixmapSize.width()) / 2);
+ m_pixmapPos.setY(padding + scaledIconSize - m_scaledPixmapSize.height());
+ } else {
+ // Center horizontally and vertically within the icon-area
+ m_pixmapPos.setX(m_textPos[Name].x() - 2 * padding
+ - (scaledIconSize + m_scaledPixmapSize.width()) / 2);
+ m_pixmapPos.setY(padding
+ + (scaledIconSize - m_scaledPixmapSize.height()) / 2);
+ }
+ m_iconRect = QRectF(m_pixmapPos, QSizeF(m_scaledPixmapSize));
+
// Prepare the pixmap that is used when the item gets hovered
- if (option.state & QStyle::State_MouseOver) {
+ if (isHovered()) {
m_hoverPixmap = m_pixmap;
KIconEffect* effect = KIconLoader::global()->iconEffect();
// In the KIconLoader terminology, active = hover.
if (effect->hasEffect(KIconLoader::Desktop, KIconLoader::ActiveState)) {
- m_hoverPixmap = effect->apply(m_pixmap, KIconLoader::Desktop, KIconLoader::ActiveState);
+ m_hoverPixmap = effect->apply(m_pixmap, KIconLoader::Desktop, KIconLoader::ActiveState);
} else {
m_hoverPixmap = m_pixmap;
}
const QHash<QByteArray, QVariant> values = data();
const KItemListStyleOption& option = styleOption();
- const qreal maxWidth = size().width() - 2 * option.margin;
+ const qreal padding = option.padding;
+ const qreal maxWidth = size().width() - 2 * padding;
const qreal widgetHeight = size().height();
const qreal fontHeight = option.fontMetrics.height();
textLinesCount += additionalRolesCount;
m_text[Name].setTextWidth(maxWidth);
- m_textPos[Name] = QPointF(option.margin, widgetHeight - textLinesCount * fontHeight - option.margin);
- m_textsBoundingRect = QRectF(option.margin + (maxWidth - requiredWidthForName) / 2,
- m_textPos[Name].y(),
- requiredWidthForName,
- m_text[Name].size().height());
+ m_textPos[Name] = QPointF(padding, widgetHeight - textLinesCount * fontHeight - padding);
+ m_textRect = QRectF(padding + (maxWidth - requiredWidthForName) / 2,
+ m_textPos[Name].y(),
+ requiredWidthForName,
+ textLinesCountForName * fontHeight);
// Calculate the position for each additional information
qreal y = m_textPos[Name].y() + textLinesCountForName * fontHeight;
continue;
}
- const QString text = roleText(textId, values[role]);
+ const QString text = roleText(role, values);
m_text[textId].setText(text);
qreal requiredWidth = 0;
// TODO: QFontMetrics::elidedText() works different regarding the given width
// in comparison to QTextLine::setLineWidth(). It might happen that the text does
// not get elided although it does not fit into the given width. As workaround
- // the margin is substracted.
- const QString elidedText = option.fontMetrics.elidedText(text, Qt::ElideRight, maxWidth - option.margin);
+ // the padding is substracted.
+ const QString elidedText = option.fontMetrics.elidedText(text, Qt::ElideRight, maxWidth - padding);
m_text[textId].setText(elidedText);
}
}
layout.endLayout();
- m_textPos[textId] = QPointF(option.margin, y);
+ m_textPos[textId] = QPointF(padding, y);
m_text[textId].setTextWidth(maxWidth);
- const QRectF textBoundingRect(option.margin + (maxWidth - requiredWidth) / 2, y, requiredWidth, fontHeight);
- m_textsBoundingRect |= textBoundingRect;
+ const QRectF textRect(padding + (maxWidth - requiredWidth) / 2, y, requiredWidth, fontHeight);
+ m_textRect |= textRect;
y += fontHeight;
}
- // Add a margin to the text bounding rectangle
- const qreal margin = option.margin;
- m_textsBoundingRect.adjust(-margin, -margin, margin, margin);
+ // Add a padding to the text rectangle
+ m_textRect.adjust(-padding, -padding, padding, padding);
}
void KFileItemListWidget::updateCompactLayoutTextCache()
const qreal widgetHeight = size().height();
const qreal fontHeight = option.fontMetrics.height();
const qreal textLinesHeight = qMax(visibleRoles().count(), 1) * fontHeight;
- const int scaledIconSize = (textLinesHeight < option.iconSize) ? widgetHeight - 2 * option.margin : option.iconSize;
+ const int scaledIconSize = (textLinesHeight < option.iconSize) ? widgetHeight - 2 * option.padding : option.iconSize;
qreal maximumRequiredTextWidth = 0;
- const qreal x = option.margin * 3 + scaledIconSize;
+ const qreal x = option.padding * 3 + scaledIconSize;
qreal y = (widgetHeight - textLinesHeight) / 2;
- const qreal maxWidth = size().width() - x - option.margin;
+ const qreal maxWidth = size().width() - x - option.padding;
foreach (const QByteArray& role, m_sortedVisibleRoles) {
const TextId textId = roleTextId(role);
- const QString text = roleText(textId, values[role]);
+ const QString text = roleText(role, values);
m_text[textId].setText(text);
qreal requiredWidth = option.fontMetrics.width(text);
y += fontHeight;
}
- m_textsBoundingRect = QRectF(x - option.margin, 0, maximumRequiredTextWidth + 2 * option.margin, widgetHeight);
+ m_textRect = QRectF(x - option.padding, 0, maximumRequiredTextWidth + 2 * option.padding, widgetHeight);
}
void KFileItemListWidget::updateDetailsLayoutTextCache()
// +------+
// | Icon | Name role Additional role 1 Additional role 2
// +------+
- m_textsBoundingRect = QRectF();
+ m_textRect = QRectF();
const KItemListStyleOption& option = styleOption();
const QHash<QByteArray, QVariant> values = data();
const qreal widgetHeight = size().height();
- const int scaledIconSize = widgetHeight - 2 * option.margin;
+ const int scaledIconSize = widgetHeight - 2 * option.padding;
const int fontHeight = option.fontMetrics.height();
- qreal x = m_expansionArea.right() + option.margin * 3 + scaledIconSize;
- const qreal y = qMax(qreal(option.margin), (widgetHeight - fontHeight) / 2);
+ const qreal columnPadding = option.padding * 3;
+ const qreal firstColumnInc = m_expansionArea.right() + option.padding * 2 + scaledIconSize;
+ qreal x = firstColumnInc;
+ const qreal y = qMax(qreal(option.padding), (widgetHeight - fontHeight) / 2);
foreach (const QByteArray& role, m_sortedVisibleRoles) {
const TextId textId = roleTextId(role);
- const QString text = roleText(textId, values[role]);
- m_text[textId].setText(text);
-
- const qreal requiredWidth = option.fontMetrics.width(text);
- m_textPos[textId] = QPointF(x, y);
+ QString text = roleText(role, values);
+ // Elide the text in case it does not fit into the available column-width
+ qreal requiredWidth = option.fontMetrics.width(text);
const qreal columnWidth = visibleRolesSizes().value(role, QSizeF(0, 0)).width();
+ qreal availableTextWidth = columnWidth - 2 * columnPadding;
+ if (textId == Name) {
+ availableTextWidth -= firstColumnInc;
+ }
+
+ if (requiredWidth > availableTextWidth) {
+ text = option.fontMetrics.elidedText(text, Qt::ElideRight, availableTextWidth);
+ requiredWidth = option.fontMetrics.width(text);
+ }
+
+ m_text[textId].setText(text);
+ m_textPos[textId] = QPointF(x + columnPadding, y);
x += columnWidth;
switch (textId) {
case Name: {
- m_textsBoundingRect = QRectF(m_textPos[textId].x() - option.margin, 0,
- requiredWidth + 2 * option.margin, size().height());
+ m_textRect = QRectF(m_textPos[textId].x() - option.padding, 0,
+ requiredWidth + 2 * option.padding, size().height());
// The column after the name should always be aligned on the same x-position independent
// from the expansion-level shown in the name column
- x -= m_expansionArea.right();
+ x -= firstColumnInc;
break;
}
case Size:
// The values for the size should be right aligned
- m_textPos[textId].rx() += columnWidth - requiredWidth - 2 * option.margin;
+ m_textPos[textId].rx() += columnWidth - requiredWidth - 2 * columnPadding;
break;
default:
}
}
-QString KFileItemListWidget::roleText(TextId textId, const QVariant& roleValue) const
+void KFileItemListWidget::updateAdditionalInfoTextColor()
{
- QString text;
-
- switch (textId) {
- case Name:
- case Permissions:
- case Owner:
- case Group:
- case Type:
- case Destination:
- case Path:
- text = roleValue.toString();
- break;
-
- case Size: {
- if (data().value("isDir").toBool()) {
- // The item represents a directory. Show the number of sub directories
- // instead of the file size of the directory.
- if (!roleValue.isNull()) {
- const KIO::filesize_t size = roleValue.value<KIO::filesize_t>();
- text = i18ncp("@item:intable", "%1 item", "%1 items", size);
- }
- } else {
- const KIO::filesize_t size = roleValue.value<KIO::filesize_t>();
- text = KIO::convertSize(size);
- }
- break;
- }
-
- case Date: {
- const QDateTime dateTime = roleValue.toDateTime();
- text = KGlobal::locale()->formatDateTime(dateTime);
- break;
- }
-
- default:
- Q_ASSERT(false);
- break;
+ QColor c1;
+ if (m_customTextColor.isValid()) {
+ c1 = m_customTextColor;
+ } else if (isSelected() && m_layout != DetailsLayout) {
+ c1 = styleOption().palette.highlightedText().color();
+ } else {
+ c1 = styleOption().palette.text().color();
}
- return text;
+ // For the color of the additional info the inactive text color
+ // is not used as this might lead to unreadable text for some color schemes. Instead
+ // the text color c1 is slightly mixed with the background color.
+ const QColor c2 = styleOption().palette.base().color();
+ const int p1 = 70;
+ const int p2 = 100 - p1;
+ m_additionalInfoTextColor = QColor((c1.red() * p1 + c2.red() * p2) / 100,
+ (c1.green() * p1 + c2.green() * p2) / 100,
+ (c1.blue() * p1 + c2.blue() * p2) / 100);
}
void KFileItemListWidget::drawPixmap(QPainter* painter, const QPixmap& pixmap)
{
- const bool isHiddenItem = m_text[Name].text().startsWith(QLatin1Char('.'));
- qreal opacity;
- if (isHiddenItem) {
- opacity = painter->opacity();
- painter->setOpacity(opacity * 0.3);
- }
-
if (m_scaledPixmapSize != pixmap.size()) {
QPixmap scaledPixmap = pixmap;
KPixmapModifier::scale(scaledPixmap, m_scaledPixmapSize);
painter->drawPixmap(m_pixmapPos, scaledPixmap);
#ifdef KFILEITEMLISTWIDGET_DEBUG
- painter->setPen(Qt::green);
- painter->drawRect(QRectF(m_pixmapPos, QSizeF(scaledPixmap.size())));
+ painter->setPen(Qt::blue);
+ painter->drawRect(QRectF(m_pixmapPos, QSizeF(m_scaledPixmapSize)));
#endif
} else {
painter->drawPixmap(m_pixmapPos, pixmap);
}
-
- if (isHiddenItem) {
- painter->setOpacity(opacity);
- }
}
QPixmap KFileItemListWidget::pixmapForIcon(const QString& name, int size)
return rolesHash.value(role);
}
+void KFileItemListWidget::applyCutEffect(QPixmap& pixmap)
+{
+ KIconEffect* effect = KIconLoader::global()->iconEffect();
+ pixmap = effect->apply(pixmap, KIconLoader::Desktop, KIconLoader::DisabledState);
+}
+
+void KFileItemListWidget::applyHiddenEffect(QPixmap& pixmap)
+{
+ KIconEffect::semiTransparent(pixmap);
+}
+
#include "kfileitemlistwidget.moc"
projects / dolphin.git / blobdiff