#include "tooltipmanager.h"
+#include "dolphintooltip.h"
#include "dolphinmodel.h"
#include "dolphinsortfilterproxymodel.h"
-#include <kformattedballoontipdelegate.h>
#include <kicon.h>
#include <ktooltip.h>
+#include <kio/previewjob.h>
#include <QApplication>
#include <QDesktopWidget>
#include <QTimer>
#include <QToolTip>
-K_GLOBAL_STATIC(KFormattedBalloonTipDelegate, g_delegate)
+const int PREVIEW_WIDTH = 256;
+const int PREVIEW_HEIGHT = 256;
+const int ICON_WIDTH = 128;
+const int ICON_HEIGHT = 128;
+const int PREVIEW_DELAY = 250;
+
+K_GLOBAL_STATIC(DolphinBalloonTooltipDelegate, g_delegate)
ToolTipManager::ToolTipManager(QAbstractItemView* parent,
DolphinSortFilterProxyModel* model) :
m_dolphinModel(0),
m_proxyModel(model),
m_timer(0),
+ m_previewTimer(0),
+ m_waitOnPreviewTimer(0),
m_item(),
- m_itemRect()
+ m_itemRect(),
+ m_preview(false),
+ m_generatingPreview(false),
+ m_previewIsLate(false),
+ m_previewPass(0),
+ m_emptyRenderedKToolTipItem(0),
+ m_pix()
{
KToolTip::setToolTipDelegate(g_delegate);
m_timer = new QTimer(this);
m_timer->setSingleShot(true);
connect(m_timer, SIGNAL(timeout()),
- this, SLOT(showToolTip()));
+ this, SLOT(prepareToolTip()));
+
+ m_previewTimer = new QTimer(this);
+ m_previewTimer->setSingleShot(true);
+ connect(m_previewTimer, SIGNAL(timeout()),
+ this, SLOT(startPreviewJob()));
+
+ m_waitOnPreviewTimer = new QTimer(this);
+ m_waitOnPreviewTimer->setSingleShot(true);
+ connect(m_waitOnPreviewTimer, SIGNAL(timeout()),
+ this, SLOT(prepareToolTip()));
m_view->viewport()->installEventFilter(this);
}
void ToolTipManager::requestToolTip(const QModelIndex& index)
{
if (index.column() == DolphinModel::Name) {
+ m_waitOnPreviewTimer->stop();
KToolTip::hideTip();
m_itemRect = m_view->visualRect(index);
const QModelIndex dirIndex = m_proxyModel->mapToSource(index);
m_item = m_dolphinModel->itemForIndex(dirIndex);
+ // Only start the previewJob when the mouse has been over this item for 200msec,
+ // this prevents a lot of useless previewJobs (when passing rapidly over a lot of items).
+ m_previewTimer->start(200);
+ // reset these variables
+ m_preview = false;
+ m_previewIsLate = false;
+ m_previewPass = 0;
+
m_timer->start(500);
} else {
hideToolTip();
void ToolTipManager::hideToolTip()
{
m_timer->stop();
+ m_previewTimer->stop();
+ m_waitOnPreviewTimer->stop();
+ m_previewIsLate = false;
KToolTip::hideTip();
}
-void ToolTipManager::showToolTip()
+void ToolTipManager::prepareToolTip()
{
- KToolTipItem* tip = new KToolTipItem(KIcon(m_item.iconName()), m_item.getToolTipText());
+ if (m_generatingPreview) {
+ if (m_previewPass == 1) {
+ // We waited 250msec and the preview is still not finished,
+ // so show the toolTip with a transparent image of maximal width.
+ // When the preview finishes, m_previewIsLate will cause
+ // a direct update of the tooltip, via m_emptyRenderedKToolTipItem.
+ QPixmap paddedImage(QSize(PREVIEW_WIDTH, 32));
+ m_previewIsLate = true;
+ paddedImage.fill(Qt::transparent);
+ KToolTipItem* toolTip = new KToolTipItem(paddedImage, m_item.getToolTipText());
+ m_emptyRenderedKToolTipItem = toolTip; // make toolTip accessible everywhere
+ showToolTip(toolTip);
+ }
+
+ ++m_previewPass;
+ m_waitOnPreviewTimer->start(250);
+ } else {
+ // The preview generation has finished, find out under which circumstances.
+ if (m_preview && m_previewIsLate) {
+ // We got a preview, but it is late, the tooltip has already been shown.
+ // So update the tooltip directly.
+ m_emptyRenderedKToolTipItem->setData(Qt::DecorationRole, KIcon(m_pix));
+ return;
+ }
+ KIcon icon;
+ if (m_preview) {
+ // We got a preview.
+ icon = KIcon(m_pix);
+ } else {
+ // No preview, so use an icon.
+ // Force a 128x128 icon, a 256x256 one is far too big.
+ icon = KIcon(KIcon(m_item.iconName()).pixmap(ICON_WIDTH, ICON_HEIGHT));
+ }
+
+ KToolTipItem* toolTip = new KToolTipItem(icon, m_item.getToolTipText());
+ showToolTip(toolTip);
+ }
+}
+
+void ToolTipManager::showToolTip(KToolTipItem* tip)
+{
KStyleOptionToolTip option;
// TODO: get option content from KToolTip or add KToolTip::sizeHint() method
option.direction = QApplication::layoutDirection();
option.state = QStyle::State_None;
option.decorationSize = QSize(32, 32);
- const QSize size = g_delegate->sizeHint(&option, tip);
- const QRect desktop = QApplication::desktop()->availableGeometry();
+ QSize size;
+ if (m_previewIsLate) {
+ QPixmap paddedImage(QSize(PREVIEW_WIDTH, PREVIEW_HEIGHT));
+ KToolTipItem* maxiTip = new KToolTipItem(paddedImage, m_item.getToolTipText());
+ size = g_delegate->sizeHint(&option, maxiTip);
+ delete maxiTip;
+ maxiTip = 0;
+ }
+ else {
+ size = g_delegate->sizeHint(&option, tip);
+ }
+ const QRect desktop = QApplication::desktop()->screenGeometry(m_itemRect.bottomRight());
// m_itemRect defines the area of the item, where the tooltip should be
// shown. Per default the tooltip is shown in the bottom right corner.
// If the tooltip content exceeds the desktop borders, it must be assured that:
// - the content is fully visible
// - the content is not drawn inside m_itemRect
- int x = m_itemRect.right();
- int y = m_itemRect.bottom();
- const int xDiff = x + size.width() - desktop.width();
- const int yDiff = y + size.height() - desktop.height();
-
- if ((xDiff > 0) && (yDiff > 0)) {
- x = m_itemRect.left() - size.width();
- y = m_itemRect.top() - size.height();
- } else if (xDiff > 0) {
- x -= xDiff;
- } else if (yDiff > 0) {
- y -= yDiff;
+ const bool hasRoomToLeft = (m_itemRect.left() - size.width() >= desktop.left());
+ const bool hasRoomToRight = (m_itemRect.right() + size.width() <= desktop.right());
+ const bool hasRoomAbove = (m_itemRect.top() - size.height() >= desktop.top());
+ const bool hasRoomBelow = (m_itemRect.bottom() + size.height() <= desktop.bottom());
+ if (!hasRoomAbove && !hasRoomBelow && !hasRoomToLeft && !hasRoomToRight) {
+ delete tip;
+ tip = 0;
+ return;
+ }
+
+ int x = 0;
+ int y = 0;
+ if (hasRoomBelow || hasRoomAbove) {
+ x = QCursor::pos().x() + 16; // TODO: use mouse pointer width instead of the magic value of 16
+ if (x + size.width() >= desktop.right()) {
+ x = desktop.right() - size.width();
+ }
+ y = hasRoomBelow ? m_itemRect.bottom() : m_itemRect.top() - size.height();
+ } else {
+ Q_ASSERT(hasRoomToLeft || hasRoomToRight);
+ x = hasRoomToRight ? m_itemRect.right() : m_itemRect.left() - size.width();
+
+ // Put the tooltip at the bottom of the screen. The x-coordinate has already
+ // been adjusted, so that no overlapping with m_itemRect occurs.
+ y = desktop.bottom() - size.height();
}
KToolTip::showTip(QPoint(x, y), tip);
}
+
+
+void ToolTipManager::startPreviewJob()
+{
+ m_generatingPreview = true;
+ KIO::PreviewJob* job = KIO::filePreview(KUrl::List() << m_item.url(),
+ PREVIEW_WIDTH,
+ PREVIEW_HEIGHT);
+ job->setIgnoreMaximumSize(true);
+
+ connect(job, SIGNAL(gotPreview(const KFileItem&, const QPixmap&)),
+ this, SLOT(setPreviewPix(const KFileItem&, const QPixmap&)));
+ connect(job, SIGNAL(failed(const KFileItem&)),
+ this, SLOT(previewFailed(const KFileItem&)));
+}
+
+
+void ToolTipManager::setPreviewPix(const KFileItem& item,
+ const QPixmap& pixmap)
+{
+ if (m_item.url() != item.url()) {
+ m_generatingPreview = false;
+ return;
+ }
+
+ QPixmap icon = pixmap;
+ // only paint borders if the pixmap is opaque
+ if (!icon.hasAlphaChannel()) {
+ // TODO: Make code from IconManager for drawing a border accessible for
+ // other classes (the following code has been adapted from IconManager).
+ // The frame is painted on top of the pixmap, this is needed to keep
+ // the text preview visually nice (the previewer adds ugly borders).
+ QPainter painter;
+ // make a buffer pixmap, tends to crash when 'icon' is directly painted ...
+ QPixmap framedIcon(icon.size().width(), pixmap.size().height());
+ framedIcon.fill();
+ const int width = framedIcon.width() - 1;
+ const int height = framedIcon.height() - 1;
+
+ // draw the pixmap
+ painter.begin(&framedIcon);
+ painter.drawPixmap(0,0, icon);
+
+ // draw the frame
+ painter.setRenderHint(QPainter::Antialiasing, false);
+ painter.setPen(QColor(0, 0, 0));
+ painter.drawRect(0, 0, width - 0, height - 1);
+ painter.drawRect(1, 1, width - 2, height - 2);
+ painter.setPen(QColor(255, 255, 255));
+ painter.drawRect(2, 2, width - 4, height - 4);
+
+ painter.end();
+ icon = framedIcon;
+
+ // provide an alpha channel for the frame
+ QPixmap alphaChannel(icon.size());
+ alphaChannel.fill();
+
+ QPainter alphaPainter(&alphaChannel);
+ alphaPainter.setBrush(Qt::NoBrush);
+ alphaPainter.setRenderHint(QPainter::Antialiasing, false);
+ alphaPainter.setPen(QColor(32, 32, 32));
+ alphaPainter.drawRect(0, 0, width, height);
+ alphaPainter.setPen(QColor(64, 64, 64));
+ alphaPainter.drawRect(1, 1, width - 2, height - 2);
+
+ icon.setAlphaChannel(alphaChannel);
+ }
+
+ if (m_previewIsLate) {
+ // always use the maximal width
+ QPixmap paddedImage(QSize(PREVIEW_WIDTH, icon.height()));
+ paddedImage.fill(Qt::transparent);
+ QPainter painter(&paddedImage);
+ painter.drawPixmap((PREVIEW_WIDTH - icon.width()) / 2, 0, icon);
+ m_pix = paddedImage;
+ } else {
+ m_pix = icon;
+ }
+ m_preview = true;
+ m_generatingPreview = false;
+}
+
+void ToolTipManager::previewFailed(const KFileItem& item)
+{
+ Q_UNUSED(item);
+ m_generatingPreview = false;
+}
+
#include "tooltipmanager.moc"
projects / dolphin.git / blobdiff