Add author-abandoned basket application

git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/basket@1072339 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 807 insertions, 0 deletions

diff --git a/src/basketlistview.cpp b/src/basketlistview.cpp
new file mode 100644
index 0000000..51b9747
--- /dev/null
+++ b/src/basketlistview.cpp
@@ -0,0 +1,807 @@
+/***************************************************************************
+ *   Copyright (C) 2003 by S�astien Laot                                 *
+ *   slaout@linux62.org                                                    *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   This program is distributed in the hope that it will be useful,       *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+ *   GNU General Public License for more details.                          *
+ *                                                                         *
+ *   You should have received a copy of the GNU General Public License     *
+ *   along with this program; if not, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.             *
+ ***************************************************************************/
+
+#include "basketlistview.h"
+#include <qregexp.h>
+#include <kglobalsettings.h>
+#include <kiconloader.h>
+#include <klocale.h>
+#include <kstringhandler.h>
+#include <qpainter.h>
+#include <qbitmap.h>
+#include <qpixmapcache.h>
+#include <qtooltip.h>
+#include <iostream>
+#include <kdebug.h>
+#include "global.h"
+#include "bnpview.h"
+#include "basket.h"
+#include "tools.h"
+#include "settings.h"
+#include "notedrag.h"
+
+/** class BasketListViewItem: */
+
+BasketListViewItem::BasketListViewItem(QListView *parent, Basket *basket)
+	: QListViewItem(parent), m_basket(basket)
+	, m_isUnderDrag(false)
+	, m_isAbbreviated(false)
+{
+	setDropEnabled(true);
+}
+
+BasketListViewItem::BasketListViewItem(QListViewItem *parent, Basket *basket)
+	: QListViewItem(parent), m_basket(basket)
+	, m_isUnderDrag(false)
+	, m_isAbbreviated(false)
+{
+	setDropEnabled(true);
+}
+
+BasketListViewItem::BasketListViewItem(QListView *parent, QListViewItem *after, Basket *basket)
+	: QListViewItem(parent, after), m_basket(basket)
+	, m_isUnderDrag(false)
+	, m_isAbbreviated(false)
+{
+	setDropEnabled(true);
+}
+
+BasketListViewItem::BasketListViewItem(QListViewItem *parent, QListViewItem *after, Basket *basket)
+	: QListViewItem(parent, after), m_basket(basket)
+	, m_isUnderDrag(false)
+	, m_isAbbreviated(false)
+{
+	setDropEnabled(true);
+}
+
+BasketListViewItem::~BasketListViewItem()
+{
+}
+
+bool BasketListViewItem::acceptDrop(const QMimeSource *) const
+{
+	std::cout << "accept" << std::endl;
+	return true;
+}
+
+void BasketListViewItem::dropped(QDropEvent *event)
+{
+	std::cout << "Dropping into basket " << m_basket->name() << std::endl;
+	m_basket->contentsDropEvent(event);
+	//Global::bnpView->currentBasket()->contentsDropEvent(event); // FIXME
+}
+
+int BasketListViewItem::width(const QFontMetrics &/* fontMetrics */, const QListView */*listView*/, int /* column */) const
+{
+	return listView()->visibleWidth() + 100;
+/*
+	int BASKET_ICON_SIZE = 16;
+	int MARGIN = 1;
+
+	QRect textRect = fontMetrics.boundingRect(0, 0, / *width=* /1, 500000, Qt::AlignAuto | Qt::AlignTop | Qt::ShowPrefix, text(column));
+
+	return MARGIN + BASKET_ICON_SIZE + MARGIN + textRect.width() +   BASKET_ICON_SIZE/2   + MARGIN;
+*/
+}
+
+QString BasketListViewItem::escapedName(const QString &string)
+{
+	// Underlining the Alt+Letter shortcut (and escape all other '&' characters), if any:
+	QString basketName = string;
+	basketName.replace('&', "&&"); // First escape all the amperstamp
+	QString letter; // Find the letter
+	QString altKey   = /*i18n(*/"Alt"/*)*/;   //i18n("The [Alt] key, as shown in shortcuts like Alt+C...", "Alt");
+	QString shiftKey = /*i18n(*/"Shift"/*)*/; //i18n("The [Shift] key, as shown in shortcuts like Alt+Shift+1...", "Shift");
+	QRegExp altLetterExp(      QString("^%1\\+(.)$").arg(altKey)                );
+	QRegExp altShiftLetterExp( QString("^%1\\+%2\\+(.)$").arg(altKey, shiftKey) );
+	if (altLetterExp.search(m_basket->shortcut().toStringInternal()) != -1)
+		letter = altLetterExp.cap(1);
+	if (letter.isEmpty() && altShiftLetterExp.search(m_basket->shortcut().toStringInternal()) != -1)
+		letter = altShiftLetterExp.cap(1);
+	if (!letter.isEmpty()) {
+		int index = basketName.find(letter, /*index=*/0, /*caseSensitive=*/false);
+		if (index != -1)
+			basketName.insert(index, '&');
+	}
+	return basketName;
+}
+
+void BasketListViewItem::setup()
+{
+	int BASKET_ICON_SIZE = 16;
+	int MARGIN = 1;
+
+	setText(/*column=*/0, escapedName(m_basket->basketName()));
+
+	widthChanged();
+	QRect textRect = listView()->fontMetrics().boundingRect(0, 0, /*width=*/1, 500000, Qt::AlignAuto | Qt::AlignTop | Qt::ShowPrefix, text(/*column=*/0));
+
+	int height = MARGIN + QMAX(BASKET_ICON_SIZE, textRect.height()) + MARGIN;
+	setHeight(height);
+
+	QPixmap icon = kapp->iconLoader()->loadIcon(m_basket->icon(), KIcon::NoGroup, 16, KIcon::DefaultState, 0L, /*canReturnNull=*/false);
+
+	setPixmap(/*column=*/0, icon);
+
+	repaint();
+}
+
+BasketListViewItem* BasketListViewItem::lastChild()
+{
+	QListViewItem *child = firstChild();
+	while (child) {
+		if (child->nextSibling())
+			child = child->nextSibling();
+		else
+			return (BasketListViewItem*)child;
+	}
+	return 0;
+}
+
+BasketListViewItem* BasketListViewItem::prevSibling()
+{
+	BasketListViewItem *item = this;
+	while (item) {
+		if (item->nextSibling() == this)
+			return item;
+		item = (BasketListViewItem*)(item->itemAbove());
+	}
+	return 0;
+}
+
+BasketListViewItem* BasketListViewItem::shownItemAbove()
+{
+	BasketListViewItem *item = (BasketListViewItem*)itemAbove();
+	while (item) {
+		if (item->isShown())
+			return item;
+		item = (BasketListViewItem*)(item->itemAbove());
+	}
+	return 0;
+}
+
+BasketListViewItem* BasketListViewItem::shownItemBelow()
+{
+	BasketListViewItem *item = (BasketListViewItem*)itemBelow();
+	while (item) {
+		if (item->isShown())
+			return item;
+		item = (BasketListViewItem*)(item->itemBelow());
+	}
+	return 0;
+}
+
+QStringList BasketListViewItem::childNamesTree(int deep)
+{
+	QStringList result;
+	for (QListViewItem *child = firstChild(); child; child = child->nextSibling()) {
+		BasketListViewItem *item = (BasketListViewItem*)child;
+		// Compute indentation spaces:
+		QString spaces;
+		for (int i = 0; i < deep; ++i)
+			spaces += "  ";
+		// Append the name:
+		result.append(spaces + item->basket()->basketName());
+		// Append the childs:
+		if (child->firstChild()) {
+			QStringList childs = item->childNamesTree(deep + 1);
+			for (QStringList::iterator it = childs.begin(); it != childs.end(); ++it)
+				result.append(*it);
+		}
+	}
+	return result;
+}
+
+void BasketListViewItem::moveChildsBaskets()
+{
+	QListViewItem *insertAfterThis = this;
+	QListViewItem *nextOne;
+	for (QListViewItem *child = firstChild(); child; child = nextOne) {
+		nextOne = child->nextSibling();
+		// Re-insert the item with the good parent:
+		takeItem(child);
+		if (parent())
+			parent()->insertItem(child);
+		else
+			listView()->insertItem(child);
+		// And move it at the good place:
+		child->moveItem(insertAfterThis);
+		insertAfterThis = child;
+	}
+}
+
+void BasketListViewItem::ensureVisible()
+{
+	BasketListViewItem *item = this;
+	while (item->parent()) {
+		item = (BasketListViewItem*)(item->parent());
+		item->setOpen(true);
+	}
+}
+
+bool BasketListViewItem::isShown()
+{
+	QListViewItem *item = parent();
+	while (item) {
+		if (!item->isOpen())
+			return false;
+		item = item->parent();
+	}
+	return true;
+}
+
+bool BasketListViewItem::isCurrentBasket()
+{
+	return basket() == Global::bnpView->currentBasket();
+}
+
+// TODO: Move this function from item.cpp to class Tools:
+extern void drawGradient( QPainter *p, const QColor &colorTop, const QColor & colorBottom,
+						  int x, int y, int w, int h,
+						  bool sunken, bool horz, bool flat  ); /*const*/
+
+QPixmap BasketListViewItem::circledTextPixmap(const QString &text, int height, const QFont &font, const QColor &color)
+{
+	QString key = QString("BLI-%1.%2.%3.%4")
+		.arg(text).arg(height).arg(font.toString()).arg(color.rgb());
+	if (QPixmap* cached=QPixmapCache::find(key)) {
+		return *cached;
+	}
+
+	// Compute the sizes of the image components:
+	QRect textRect = QFontMetrics(font).boundingRect(0, 0, /*width=*/1, height, Qt::AlignAuto | Qt::AlignTop, text);
+	int xMargin = height / 6;
+	int width   = xMargin + textRect.width() + xMargin;
+
+	// Create the gradient image:
+	QPixmap gradient(3 * width, 3 * height); // We double the size to be able to smooth scale down it (== antialiased curves)
+	QPainter gradientPainter(&gradient);
+#if 1 // Enable the new look of the gradient:
+	QColor topColor       = KGlobalSettings::highlightColor().light(130); //120
+	QColor topMidColor    = KGlobalSettings::highlightColor().light(105); //105
+	QColor bottomMidColor = KGlobalSettings::highlightColor().dark(130);  //120
+	QColor bottomColor    = KGlobalSettings::highlightColor();
+	drawGradient(&gradientPainter, topColor, topMidColor,
+				  0, 0, gradient.width(), gradient.height() / 2, /*sunken=*/false, /*horz=*/true, /*flat=*/false);
+	drawGradient(&gradientPainter, bottomMidColor, bottomColor,
+				  0, gradient.height() / 2, gradient.width(), gradient.height() - gradient.height() / 2, /*sunken=*/false, /*horz=*/true, /*flat=*/false);
+	gradientPainter.fillRect(0, 0, gradient.width(), 3, KGlobalSettings::highlightColor());
+#else
+	drawGradient(&gradientPainter, KGlobalSettings::highlightColor(), KGlobalSettings::highlightColor().dark(),
+				  0, 0, gradient.width(), gradient.height(), /*sunken=*/false, /*horz=*/true, /*flat=*/false);
+#endif
+	gradientPainter.end();
+
+	// Draw the curved rectangle:
+	QBitmap curvedRectangle(3 * width, 3 * height);
+	curvedRectangle.fill(Qt::color0);
+	QPainter curvePainter(&curvedRectangle);
+	curvePainter.setPen(Qt::color1);
+	curvePainter.setBrush(Qt::color1);
+	curvePainter.setClipRect(0, 0, 3*(height / 5), 3*(height)); // If the width is small, don't fill the right part of the pixmap
+	curvePainter.drawEllipse(0, 3*(-height / 4), 3*(height), 3*(height * 3 / 2)); // Don't forget we double the sizes
+	curvePainter.setClipRect(3*(width - height / 5), 0, 3*(height / 5), 3*(height));
+	curvePainter.drawEllipse(3*(width - height), 3*(-height / 4), 3*(height), 3*(height * 3 / 2));
+	curvePainter.setClipping(false);
+	curvePainter.fillRect(3*(height / 6), 0, 3*(width - 2 * height / 6), 3*(height), curvePainter.brush());
+	curvePainter.end();
+
+	// Apply the curved rectangle as the mask of the gradient:
+	gradient.setMask(curvedRectangle);
+	QImage resultImage = gradient.convertToImage();
+	resultImage.setAlphaBuffer(true);
+
+	// Scale down the image smoothly to get anti-aliasing:
+	QPixmap pmScaled;
+	pmScaled.convertFromImage(resultImage.smoothScale(width, height));
+
+	// Draw the text, and return the result:
+	QPainter painter(&pmScaled);
+	painter.setPen(color);
+	painter.setFont(font);
+	painter.drawText(0+1, 0, width, height, Qt::AlignHCenter | Qt::AlignVCenter, text);
+	painter.end();
+
+	QPixmapCache::insert(key, pmScaled);
+
+	return pmScaled;
+}
+
+QPixmap BasketListViewItem::foundCountPixmap(bool isLoading, int countFound, bool childsAreLoading, int countChildsFound, const QFont &font, int height)
+{
+	if (isLoading)
+		return QPixmap();
+
+	QFont boldFont(font);
+	boldFont.setBold(true);
+
+	QString text;
+	if (childsAreLoading) {
+		if (countChildsFound > 0)
+			text = i18n("%1+%2+").arg(QString::number(countFound), QString::number(countChildsFound));
+		else
+			text = i18n("%1+").arg(QString::number(countFound));
+	} else {
+		if (countChildsFound > 0)
+			text = i18n("%1+%2").arg(QString::number(countFound), QString::number(countChildsFound));
+		else if (countFound > 0)
+			text = QString::number(countFound);
+		else
+			return QPixmap();
+	}
+
+	return circledTextPixmap(text, height, boldFont, KGlobalSettings::highlightedTextColor());
+}
+
+bool BasketListViewItem::haveChildsLoading()
+{
+	QListViewItem *child = firstChild();
+	while (child) {
+		BasketListViewItem *childItem = (BasketListViewItem*)child;
+		if (!childItem->basket()->isLoaded() && !childItem->basket()->isLocked())
+			return true;
+		if (childItem->haveChildsLoading())
+			return true;
+		child = child->nextSibling();
+	}
+	return false;
+}
+
+bool BasketListViewItem::haveHiddenChildsLoading()
+{
+	if (isOpen())
+		return false;
+	return haveChildsLoading();
+}
+
+bool BasketListViewItem::haveChildsLocked()
+{
+	QListViewItem *child = firstChild();
+	while (child) {
+		BasketListViewItem *childItem = (BasketListViewItem*)child;
+		if (/*!*/childItem->basket()->isLocked())
+			return true;
+		if (childItem->haveChildsLocked())
+			return true;
+		child = child->nextSibling();
+	}
+	return false;
+}
+
+bool BasketListViewItem::haveHiddenChildsLocked()
+{
+	if (isOpen())
+		return false;
+	return haveChildsLocked();
+}
+
+int BasketListViewItem::countChildsFound()
+{
+	int count = 0;
+	QListViewItem *child = firstChild();
+	while (child) {
+		BasketListViewItem *childItem = (BasketListViewItem*)child;
+		count += childItem->basket()->countFounds();
+		count += childItem->countChildsFound();
+		child = child->nextSibling();
+	}
+	return count;
+}
+
+int BasketListViewItem::countHiddenChildsFound()
+{
+	if (isOpen())
+		return 0;
+	return countChildsFound();
+}
+
+void BasketListViewItem::paintCell(QPainter *painter, const QColorGroup &/*colorGroup*/, int /*column*/, int width, int /*align*/)
+{
+	// Workaround a Qt bug:
+	// When the splitter is moved to hide the tree view and then the application is restarted,
+	// Qt try to draw items with a negative size!
+	if (width <= 0) {
+		std::cout << "width <= 0" << std::endl;
+		return;
+	}
+
+	int BASKET_ICON_SIZE = 16;
+	int MARGIN = 1;
+
+
+	// If we are filtering all baskets, and are effectively filtering on something:
+	bool showLoadingIcon = false;
+	bool showEncryptedIcon = false;
+	QPixmap countPixmap;
+	bool showCountPixmap = Global::bnpView->isFilteringAllBaskets() &&
+		Global::bnpView->currentBasket()->decoration()->filterBar()->filterData().isFiltering;
+	if (showCountPixmap) {
+		showLoadingIcon = (!m_basket->isLoaded() && !m_basket->isLocked()) || haveHiddenChildsLoading();
+		showEncryptedIcon = m_basket->isLocked() || haveHiddenChildsLocked();
+		countPixmap = foundCountPixmap(!m_basket->isLoaded(), m_basket->countFounds(), haveHiddenChildsLoading() || haveHiddenChildsLocked(),
+										countHiddenChildsFound(), listView()->font(), height() - 2 * MARGIN);
+	}
+	int effectiveWidth = width - (countPixmap.isNull() ? 0 : countPixmap.width() + MARGIN)
+			- (showLoadingIcon || showEncryptedIcon ? BASKET_ICON_SIZE + MARGIN : 0)/*
+			- (showEncryptedIcon ? BASKET_ICON_SIZE + MARGIN : 0)*/;
+
+
+	bool drawRoundRect = m_basket->backgroundColorSetting().isValid() || m_basket->textColorSetting().isValid();
+	QColor textColor = (drawRoundRect ? m_basket->textColor() : (isCurrentBasket() ? KGlobalSettings::highlightedTextColor() : KGlobalSettings::textColor()));
+
+	BasketListViewItem *shownAbove = shownItemAbove();
+	BasketListViewItem *shownBelow = shownItemBelow();
+
+	// Don't forget to update the key computation if parameters
+	// affecting the rendering logic change
+	QString key = QString("BLVI::pC-%1.%2.%3.%4.%5.%6.%7.%8.%9.%10.%11.%12.%13.%14.%15")
+		.arg(effectiveWidth)
+		.arg(drawRoundRect)
+		.arg(textColor.rgb())
+		.arg(m_basket->backgroundColor().rgb())
+		.arg(isCurrentBasket())
+		.arg(shownBelow && shownBelow->isCurrentBasket())
+		.arg(shownAbove && shownAbove->isCurrentBasket())
+		.arg(showLoadingIcon)
+		.arg(showEncryptedIcon)
+		.arg(showCountPixmap)
+		.arg(m_basket->countFounds())
+		.arg(countHiddenChildsFound())
+		.arg(m_isUnderDrag)
+		.arg(m_basket->basketName())
+		.arg(m_basket->icon());
+	if (QPixmap* cached = QPixmapCache::find(key)) {
+		// Qt's documentation recommends copying the pointer
+		// into a QPixmap immediately
+		QPixmap cachedBuffer = *cached;
+		painter->drawPixmap(0, 0, cachedBuffer);
+		return;
+	}
+
+	// Bufferize the drawing of items (otherwize, resizing the splitter make the tree act like a Christmas Tree ;-D ):
+	QPixmap theBuffer(width, height());
+	QPainter thePainter(&theBuffer);
+
+	// Fill with the basket background color:
+	QColor background = (isCurrentBasket() ? KGlobalSettings::highlightColor() : listView()->paletteBackgroundColor());
+	thePainter.fillRect(0, 0, width, height(), background);
+
+	int textWidth = effectiveWidth - MARGIN - BASKET_ICON_SIZE - MARGIN - MARGIN;
+
+	// Draw the rounded rectangle:
+	if (drawRoundRect) {
+		QRect textRect = listView()->fontMetrics().boundingRect(0, 0, /*width=*/1, 500000, Qt::AlignAuto | Qt::AlignTop | Qt::ShowPrefix, text(/*column=*/0));
+		int xRound = MARGIN;
+		int yRound = MARGIN;
+		int hRound = height() - 2 * MARGIN;
+		int wRound = QMIN(BASKET_ICON_SIZE + MARGIN + textRect.width() + hRound/2,  effectiveWidth - MARGIN - MARGIN);
+		if (wRound > 0) { // Do not crash if there is no space anymore to draw the rounded rectangle:
+			QPixmap buffer(wRound * 2, hRound * 2);
+			buffer.fill(background);
+			QPainter pBuffer(&buffer);
+			QColor colorRound = m_basket->backgroundColor();
+			pBuffer.setPen(colorRound);
+			pBuffer.setBrush(colorRound);
+			if (wRound > hRound) { // If the rectangle is smaller in width than in height, don't overlap ellipses...
+				pBuffer.drawEllipse(0,                                 0, hRound * 2, hRound * 2);
+				pBuffer.drawEllipse(wRound * 2 - hRound * 2, 0, hRound * 2, hRound * 2);
+				pBuffer.fillRect(hRound*2/2, 0, wRound * 2 - hRound * 2, hRound * 2, colorRound);
+			} else
+				pBuffer.drawEllipse(0, 0, wRound * 2, hRound * 2);
+				pBuffer.end();
+				QImage imageToScale = buffer.convertToImage();
+				QPixmap pmScaled;
+				pmScaled.convertFromImage(imageToScale.smoothScale(wRound, hRound));
+				thePainter.drawPixmap(xRound, yRound, pmScaled);
+				textWidth -= hRound/2;
+		}
+	}
+
+	QColor bgColor  = listView()->paletteBackgroundColor();
+	QColor selColor = KGlobalSettings::highlightColor();
+	QColor midColor = Tools::mixColor(bgColor, selColor);
+	// Draw the left selection roundings:
+	if (isCurrentBasket()) {
+		thePainter.setPen(bgColor);
+		thePainter.drawPoint(0, 0);
+		thePainter.drawPoint(1, 0);
+		thePainter.drawPoint(0, 1);
+		thePainter.drawPoint(0, height() - 1);
+		thePainter.drawPoint(1, height() - 1);
+		thePainter.drawPoint(0, height() - 2);
+		thePainter.setPen(midColor);
+		thePainter.drawPoint(2, 0);
+		thePainter.drawPoint(0, 2);
+		thePainter.drawPoint(2, height() - 1);
+		thePainter.drawPoint(0, height() - 3);
+	}
+	// Draw the bottom-right selection roundings:
+	//BasketListViewItem *shownBelow = shownItemBelow();
+	if (shownBelow && shownBelow->isCurrentBasket()) {
+		thePainter.setPen(selColor);
+		thePainter.drawPoint(width - 1, height() - 1);
+		thePainter.drawPoint(width - 2, height() - 1);
+		thePainter.drawPoint(width - 1, height() - 2);
+		thePainter.setPen(midColor);
+		thePainter.drawPoint(width - 3, height() - 1);
+		thePainter.drawPoint(width - 1, height() - 3);
+	}
+	// Draw the top-right selection roundings:
+	//	BasketListViewItem *shownAbove = shownItemAbove();
+	if (shownAbove && shownAbove->isCurrentBasket()) {
+		thePainter.setPen(selColor);
+		thePainter.drawPoint(width - 1, 0);
+		thePainter.drawPoint(width - 2, 0);
+		thePainter.drawPoint(width - 1, 1);
+		thePainter.setPen(midColor);
+		thePainter.drawPoint(width - 3, 0);
+		thePainter.drawPoint(width - 1, 2);
+	}
+
+	// Draw the icon and text:
+	int yPixmap = (height() - BASKET_ICON_SIZE) / 2;
+	thePainter.drawPixmap(MARGIN, yPixmap, *pixmap(/*column=*/0));
+	thePainter.setPen(textColor);
+	if (textWidth > 0) { // IF there is space left to draw the text:
+		int xText = MARGIN + BASKET_ICON_SIZE + MARGIN;
+		QString theText = m_basket->basketName();
+		if (painter->fontMetrics().width(theText) > textWidth) {
+			theText = KStringHandler::rPixelSqueeze(theText, painter->fontMetrics(), textWidth);
+			m_isAbbreviated = true;
+		}
+		else {
+			m_isAbbreviated = false;
+		}
+		theText = escapedName(theText);
+		thePainter.drawText(xText, 0, textWidth, height(), Qt::AlignAuto | Qt::AlignVCenter | Qt::ShowPrefix, theText);
+	}
+
+	// If we are filtering all baskets, and are effectively filtering on something:
+	if (!countPixmap.isNull())
+	{
+		thePainter.drawPixmap(effectiveWidth, 1, countPixmap);
+		effectiveWidth += countPixmap.width() + MARGIN;
+	}
+	if (showLoadingIcon) {
+		QPixmap icon = kapp->iconLoader()->loadIcon("find", KIcon::NoGroup, 16, KIcon::DefaultState, 0L, /*canReturnNull=*/false);
+		thePainter.drawPixmap(effectiveWidth, 0, icon);
+		effectiveWidth += BASKET_ICON_SIZE + MARGIN;
+	}
+	if (showEncryptedIcon && !showLoadingIcon) {
+		QPixmap icon = kapp->iconLoader()->loadIcon("encrypted", KIcon::NoGroup, 16, KIcon::DefaultState, 0L, /*canReturnNull=*/false);
+		thePainter.drawPixmap(effectiveWidth, 0, icon);
+	}
+
+	if (m_isUnderDrag) {
+		thePainter.drawWinFocusRect(0, 0, width, height());
+	}
+	thePainter.end();
+
+	QPixmapCache::insert(key, theBuffer);
+	// Apply the buffer:
+	painter->drawPixmap(0, 0, theBuffer);
+}
+
+void BasketListViewItem::setUnderDrag(bool underDrag)
+{
+	m_isUnderDrag = underDrag;
+}
+
+bool BasketListViewItem::isAbbreviated()
+{
+	return m_isAbbreviated;
+}
+
+/** class BasketListViewToolTip: */
+
+class BasketTreeListView_ToolTip : public QToolTip {
+public:
+	BasketTreeListView_ToolTip(BasketTreeListView* basketView)
+		: QToolTip(basketView->viewport())
+		, m_basketView(basketView)
+	{}
+public:
+	void maybeTip(const QPoint& pos)
+	{
+		QListViewItem *item = m_basketView->itemAt(m_basketView->contentsToViewport(pos));
+		BasketListViewItem* bitem = dynamic_cast<BasketListViewItem*>(item);
+		if (bitem && bitem->isAbbreviated()) {
+			tip(m_basketView->itemRect(bitem), bitem->basket()->basketName());
+		}
+	}
+private:
+	BasketTreeListView* m_basketView;
+};
+
+/** class BasketTreeListView: */
+
+BasketTreeListView::BasketTreeListView(QWidget *parent, const char *name)
+	: KListView(parent, name), m_autoOpenItem(0)
+	, m_itemUnderDrag(0)
+{
+	setWFlags(Qt::WStaticContents | WNoAutoErase);
+	clearWFlags(Qt::WStaticContents | WNoAutoErase);
+	//viewport()->clearWFlags(Qt::WStaticContents);
+	connect( &m_autoOpenTimer, SIGNAL(timeout()), this, SLOT(autoOpen()) );
+
+	new BasketTreeListView_ToolTip(this);
+}
+
+void BasketTreeListView::viewportResizeEvent(QResizeEvent *event)
+{
+	KListView::viewportResizeEvent(event);
+	triggerUpdate();
+}
+
+void BasketTreeListView::contentsDragEnterEvent(QDragEnterEvent *event)
+{
+	if (event->provides("application/x-qlistviewitem")) {
+		QListViewItemIterator it(this); // TODO: Don't show expanders if it's not a basket drag...
+		while (it.current()) {
+			QListViewItem *item = it.current();
+			if (!item->firstChild()) {
+				item->setExpandable(true);
+				item->setOpen(true);
+			}
+			++it;
+		}
+		update();
+	}
+
+	KListView::contentsDragEnterEvent(event);
+}
+
+void BasketTreeListView::removeExpands()
+{
+	QListViewItemIterator it(this);
+	while (it.current()) {
+		QListViewItem *item = it.current();
+		if (!item->firstChild())
+			item->setExpandable(false);
+		++it;
+	}
+	viewport()->update();
+}
+
+void BasketTreeListView::contentsDragLeaveEvent(QDragLeaveEvent *event)
+{
+	std::cout << "BasketTreeListView::contentsDragLeaveEvent" << std::endl;
+	m_autoOpenItem = 0;
+	m_autoOpenTimer.stop();
+	setItemUnderDrag(0);
+	removeExpands();
+	KListView::contentsDragLeaveEvent(event);
+}
+
+void BasketTreeListView::contentsDropEvent(QDropEvent *event)
+{
+	std::cout << "BasketTreeListView::contentsDropEvent()" << std::endl;
+	if (event->provides("application/x-qlistviewitem"))
+	{
+		KListView::contentsDropEvent(event);
+	}
+	else {
+		std::cout << "Forwarding dropped data to the basket" << std::endl;
+		QListViewItem *item = itemAt(contentsToViewport(event->pos()));
+		BasketListViewItem* bitem = dynamic_cast<BasketListViewItem*>(item);
+		if (bitem) {
+			bitem->basket()->blindDrop(event);
+		}
+		else {
+			std::cout << "Forwarding failed: no bitem found" << std::endl;
+		}
+	}
+
+	m_autoOpenItem = 0;
+	m_autoOpenTimer.stop();
+	setItemUnderDrag(0);
+	removeExpands();
+
+	Global::bnpView->save(); // TODO: Don't save if it was not a basket drop...
+}
+
+void BasketTreeListView::contentsDragMoveEvent(QDragMoveEvent *event)
+{
+	std::cout << "BasketTreeListView::contentsDragMoveEvent" << std::endl;
+	if (event->provides("application/x-qlistviewitem"))
+		KListView::contentsDragMoveEvent(event);
+	else {
+		QListViewItem *item = itemAt(contentsToViewport(event->pos()));
+		BasketListViewItem* bitem = dynamic_cast<BasketListViewItem*>(item);
+		if (m_autoOpenItem != item) {
+			m_autoOpenItem = item;
+			m_autoOpenTimer.start(1700, /*singleShot=*/true);
+		}
+		if (item) {
+			event->acceptAction(true);
+			event->accept(true);
+		}
+		setItemUnderDrag(bitem);
+
+		KListView::contentsDragMoveEvent(event); // FIXME: ADDED
+	}
+}
+
+void BasketTreeListView::setItemUnderDrag(BasketListViewItem* item)
+{
+	if (m_itemUnderDrag != item) {
+		if (m_itemUnderDrag) {
+			// Remove drag status from the old item
+			m_itemUnderDrag->setUnderDrag(false);
+			repaintItem(m_itemUnderDrag);
+		}
+
+		m_itemUnderDrag = item;
+
+		if (m_itemUnderDrag) {
+			// add drag status to the new item
+			m_itemUnderDrag->setUnderDrag(true);
+			repaintItem(m_itemUnderDrag);
+		}
+	}
+}
+
+void BasketTreeListView::autoOpen()
+{
+	BasketListViewItem *item = (BasketListViewItem*)m_autoOpenItem;
+	if (item)
+		Global::bnpView->setCurrentBasket(item->basket());
+}
+
+void BasketTreeListView::resizeEvent(QResizeEvent *event)
+{
+	KListView::resizeEvent(event);
+}
+
+void BasketTreeListView::paintEmptyArea(QPainter *painter, const QRect &rect)
+{
+	QListView::paintEmptyArea(painter, rect);
+
+	BasketListViewItem *last = Global::bnpView->lastListViewItem();
+	if (last && !last->isShown())
+		last = last->shownItemAbove();
+	if (last && last->isCurrentBasket()) {
+		int y = last->itemPos() + last->height();
+		QColor bgColor  = paletteBackgroundColor();
+		QColor selColor = KGlobalSettings::highlightColor();
+		QColor midColor = Tools::mixColor(bgColor, selColor);
+		painter->setPen(selColor);
+		painter->drawPoint(visibleWidth() - 1, y);
+		painter->drawPoint(visibleWidth() - 2, y);
+		painter->drawPoint(visibleWidth() - 1, y + 1);
+		painter->setPen(midColor);
+		painter->drawPoint(visibleWidth() - 3, y);
+		painter->drawPoint(visibleWidth() - 1, y + 2);
+	}
+}
+
+/** We should NEVER get focus (because of QWidget::NoFocus focusPolicy())
+ * but KListView can programatically give us the focus.
+ * So we give it to the basket.
+ */
+void BasketTreeListView::focusInEvent(QFocusEvent*)
+{
+	//KListView::focusInEvent(event);
+	Basket *basket = Global::bnpView->currentBasket();
+	if (basket)
+		basket->setFocus();
+}
+
+#include "basketlistview.moc"