src/kitemviews/kitemlistwidget.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2011 by Peter Penz <peter.penz19@gmail.com>             *
   3  *                                                                         *
   4  *   Based on the Itemviews NG project from Trolltech Labs:                *
   5  *   http://qt.gitorious.org/qt-labs/itemviews-ng                          *
   6  *                                                                         *
   7  *   This program is free software; you can redistribute it and/or modify  *
   8  *   it under the terms of the GNU General Public License as published by  *
   9  *   the Free Software Foundation; either version 2 of the License, or     *
  10  *   (at your option) any later version.                                   *
  11  *                                                                         *
  12  *   This program is distributed in the hope that it will be useful,       *
  13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  15  *   GNU General Public License for more details.                          *
  16  *                                                                         *
  17  *   You should have received a copy of the GNU General Public License     *
  18  *   along with this program; if not, write to the                         *
  19  *   Free Software Foundation, Inc.,                                       *
  20  *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA            *
  21  ***************************************************************************/
  22
  23 #include "kitemlistwidget.h"
  24
  25 #include "kitemlistview.h"
  26 #include "private/kitemlistselectiontoggle.h"
  27
  28 #include <QApplication>
  29 #include <QPainter>
  30 #include <QPropertyAnimation>
  31 #include <QStyleOption>
  32
  33 KItemListWidgetInformant::KItemListWidgetInformant()
  34 {
  35 }
  36
  37 KItemListWidgetInformant::~KItemListWidgetInformant()
  38 {
  39 }
  40
  41 KItemListWidget::KItemListWidget(KItemListWidgetInformant* informant, QGraphicsItem* parent) :
  42     QGraphicsWidget(parent, nullptr),
  43     m_informant(informant),
  44     m_index(-1),
  45     m_selected(false),
  46     m_current(false),
  47     m_hovered(false),
  48     m_alternateBackground(false),
  49     m_enabledSelectionToggle(false),
  50     m_data(),
  51     m_visibleRoles(),
  52     m_columnWidths(),
  53     m_styleOption(),
  54     m_siblingsInfo(),
  55     m_hoverOpacity(0),
  56     m_hoverCache(nullptr),
  57     m_hoverAnimation(nullptr),
  58     m_selectionToggle(nullptr),
  59     m_editedRole()
  60 {
  61 }
  62
  63 KItemListWidget::~KItemListWidget()
  64 {
  65     clearHoverCache();
  66 }
  67
  68 void KItemListWidget::setIndex(int index)
  69 {
  70     if (m_index != index) {
  71         delete m_selectionToggle;
  72         m_selectionToggle = nullptr;
  73
  74         if (m_hoverAnimation) {
  75             m_hoverAnimation->stop();
  76             m_hoverOpacity = 0;
  77         }
  78         clearHoverCache();
  79
  80         m_index = index;
  81     }
  82 }
  83
  84 int KItemListWidget::index() const
  85 {
  86     return m_index;
  87 }
  88
  89 void KItemListWidget::setData(const QHash<QByteArray, QVariant>& data,
  90                               const QSet<QByteArray>& roles)
  91 {
  92     clearHoverCache();
  93     if (roles.isEmpty()) {
  94         m_data = data;
  95         dataChanged(m_data);
  96     } else {
  97         foreach (const QByteArray& role, roles) {
  98             m_data[role] = data[role];
  99         }
 100         dataChanged(m_data, roles);
 101     }
 102     update();
 103 }
 104
 105 QHash<QByteArray, QVariant> KItemListWidget::data() const
 106 {
 107     return m_data;
 108 }
 109
 110 void KItemListWidget::paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget)
 111 {
 112     Q_UNUSED(option);
 113
 114     if (m_alternateBackground) {
 115         const QColor backgroundColor = m_styleOption.palette.color(QPalette::AlternateBase);
 116         const QRectF backgroundRect(0, 0, size().width(), size().height());
 117         painter->fillRect(backgroundRect, backgroundColor);
 118     }
 119
 120     if (m_selected && m_editedRole.isEmpty()) {
 121         const QStyle::State activeState(isActiveWindow() ? QStyle::State_Active : 0);
 122         drawItemStyleOption(painter, widget, activeState |
 123                                              QStyle::State_Enabled |
 124                                              QStyle::State_Selected |
 125                                              QStyle::State_Item);
 126     }
 127
 128     if (m_current && m_editedRole.isEmpty()) {
 129         QStyleOptionFocusRect focusRectOption;
 130         focusRectOption.initFrom(widget);
 131         focusRectOption.rect = textFocusRect().toRect();
 132         focusRectOption.state = QStyle::State_Enabled | QStyle::State_Item | QStyle::State_KeyboardFocusChange;
 133         if (m_selected) {
 134             focusRectOption.state |= QStyle::State_Selected;
 135         }
 136
 137         style()->drawPrimitive(QStyle::PE_FrameFocusRect, &focusRectOption, painter, widget);
 138     }
 139
 140     if (m_hoverOpacity > 0.0) {
 141         if (!m_hoverCache) {
 142             // Initialize the m_hoverCache pixmap to improve the drawing performance
 143             // when fading the hover background
 144             m_hoverCache = new QPixmap(size().toSize());
 145             m_hoverCache->fill(Qt::transparent);
 146
 147             QPainter pixmapPainter(m_hoverCache);
 148             const QStyle::State activeState(isActiveWindow() ? QStyle::State_Active : 0);
 149             drawItemStyleOption(&pixmapPainter, widget, activeState |
 150                                                         QStyle::State_Enabled |
 151                                                         QStyle::State_MouseOver |
 152                                                         QStyle::State_Item);
 153         }
 154
 155         const qreal opacity = painter->opacity();
 156         painter->setOpacity(m_hoverOpacity * opacity);
 157         painter->drawPixmap(0, 0, *m_hoverCache);
 158         painter->setOpacity(opacity);
 159     }
 160 }
 161
 162 void KItemListWidget::setVisibleRoles(const QList<QByteArray>& roles)
 163 {
 164     const QList<QByteArray> previousRoles = m_visibleRoles;
 165     m_visibleRoles = roles;
 166
 167     visibleRolesChanged(roles, previousRoles);
 168     update();
 169 }
 170
 171 QList<QByteArray> KItemListWidget::visibleRoles() const
 172 {
 173     return m_visibleRoles;
 174 }
 175
 176
 177 void KItemListWidget::setColumnWidth(const QByteArray& role, qreal width)
 178 {
 179     const qreal previousWidth = m_columnWidths.value(role);
 180     if (previousWidth != width) {
 181         m_columnWidths.insert(role, width);
 182         columnWidthChanged(role, width, previousWidth);
 183         update();
 184     }
 185 }
 186
 187 qreal KItemListWidget::columnWidth(const QByteArray& role) const
 188 {
 189     return m_columnWidths.value(role);
 190 }
 191
 192 void KItemListWidget::setStyleOption(const KItemListStyleOption& option)
 193 {
 194     if (m_styleOption == option) {
 195         return;
 196     }
 197
 198     const KItemListStyleOption previous = m_styleOption;
 199     clearHoverCache();
 200     m_styleOption = option;
 201     styleOptionChanged(option, previous);
 202     update();
 203 }
 204
 205 const KItemListStyleOption& KItemListWidget::styleOption() const
 206 {
 207     return m_styleOption;
 208 }
 209
 210 void KItemListWidget::setSelected(bool selected)
 211 {
 212     if (m_selected != selected) {
 213         m_selected = selected;
 214         if (m_selectionToggle) {
 215             m_selectionToggle->setChecked(selected);
 216         }
 217         selectedChanged(selected);
 218         update();
 219     }
 220 }
 221
 222 bool KItemListWidget::isSelected() const
 223 {
 224     return m_selected;
 225 }
 226
 227 void KItemListWidget::setCurrent(bool current)
 228 {
 229     if (m_current != current) {
 230         m_current = current;
 231         currentChanged(current);
 232         update();
 233     }
 234 }
 235
 236 bool KItemListWidget::isCurrent() const
 237 {
 238     return m_current;
 239 }
 240
 241 void KItemListWidget::setHovered(bool hovered)
 242 {
 243     if (hovered == m_hovered) {
 244         return;
 245     }
 246
 247     m_hovered = hovered;
 248
 249     if (!m_hoverAnimation) {
 250         m_hoverAnimation = new QPropertyAnimation(this, "hoverOpacity", this);
 251         const int duration = style()->styleHint(QStyle::SH_Widget_Animate) ? 200 : 1;
 252         m_hoverAnimation->setDuration(duration);
 253         connect(m_hoverAnimation, &QPropertyAnimation::finished, this, &KItemListWidget::slotHoverAnimationFinished);
 254     }
 255     m_hoverAnimation->stop();
 256
 257     if (hovered) {
 258         const qreal startValue = qMax(hoverOpacity(), qreal(0.1));
 259         m_hoverAnimation->setStartValue(startValue);
 260         m_hoverAnimation->setEndValue(1.0);
 261         if (m_enabledSelectionToggle && !(QApplication::mouseButtons() & Qt::LeftButton)) {
 262             initializeSelectionToggle();
 263         }
 264     } else {
 265         m_hoverAnimation->setStartValue(hoverOpacity());
 266         m_hoverAnimation->setEndValue(0.0);
 267     }
 268
 269     m_hoverAnimation->start();
 270
 271     hoveredChanged(hovered);
 272     update();
 273 }
 274
 275 bool KItemListWidget::isHovered() const
 276 {
 277     return m_hovered;
 278 }
 279
 280 void KItemListWidget::setHoverPosition(const QPointF& pos)
 281 {
 282     if (m_selectionToggle) {
 283         m_selectionToggle->setHovered(selectionToggleRect().contains(pos));
 284     }
 285 }
 286
 287 void KItemListWidget::setAlternateBackground(bool enable)
 288 {
 289     if (m_alternateBackground != enable) {
 290         m_alternateBackground = enable;
 291         alternateBackgroundChanged(enable);
 292         update();
 293     }
 294 }
 295
 296 bool KItemListWidget::alternateBackground() const
 297 {
 298     return m_alternateBackground;
 299 }
 300
 301 void KItemListWidget::setEnabledSelectionToggle(bool enable)
 302 {
 303     if (m_enabledSelectionToggle != enable) {
 304         m_enabledSelectionToggle = enable;
 305         update();
 306     }
 307 }
 308
 309 bool KItemListWidget::enabledSelectionToggle() const
 310 {
 311     return m_enabledSelectionToggle;
 312 }
 313
 314 void KItemListWidget::setSiblingsInformation(const QBitArray& siblings)
 315 {
 316     const QBitArray previous = m_siblingsInfo;
 317     m_siblingsInfo = siblings;
 318     siblingsInformationChanged(m_siblingsInfo, previous);
 319     update();
 320 }
 321
 322 QBitArray KItemListWidget::siblingsInformation() const
 323 {
 324     return m_siblingsInfo;
 325 }
 326
 327 void KItemListWidget::setEditedRole(const QByteArray& role)
 328 {
 329     if (m_editedRole != role) {
 330         const QByteArray previous = m_editedRole;
 331         m_editedRole = role;
 332         editedRoleChanged(role, previous);
 333     }
 334 }
 335
 336 QByteArray KItemListWidget::editedRole() const
 337 {
 338     return m_editedRole;
 339 }
 340
 341 bool KItemListWidget::contains(const QPointF& point) const
 342 {
 343     if (!QGraphicsWidget::contains(point)) {
 344         return false;
 345     }
 346
 347     return iconRect().contains(point) ||
 348            textRect().contains(point) ||
 349            expansionToggleRect().contains(point) ||
 350            selectionToggleRect().contains(point);
 351 }
 352
 353 QRectF KItemListWidget::textFocusRect() const
 354 {
 355     return textRect();
 356 }
 357
 358 QRectF KItemListWidget::selectionToggleRect() const
 359 {
 360     return QRectF();
 361 }
 362
 363 QRectF KItemListWidget::expansionToggleRect() const
 364 {
 365     return QRectF();
 366 }
 367
 368 QPixmap KItemListWidget::createDragPixmap(const QStyleOptionGraphicsItem* option,
 369                                           QWidget* widget)
 370 {
 371     QPixmap pixmap(size().toSize() * widget->devicePixelRatio());
 372     pixmap.setDevicePixelRatio(widget->devicePixelRatio());
 373     pixmap.fill(Qt::transparent);
 374
 375     QPainter painter(&pixmap);
 376
 377     const bool oldAlternateBackground = m_alternateBackground;
 378     const bool wasSelected = m_selected;
 379     const bool wasHovered = m_hovered;
 380
 381     setAlternateBackground(false);
 382     setSelected(false);
 383     setHovered(false);
 384
 385     paint(&painter, option, widget);
 386
 387     setAlternateBackground(oldAlternateBackground);
 388     setSelected(wasSelected);
 389     setHovered(wasHovered);
 390
 391     return pixmap;
 392 }
 393
 394 void KItemListWidget::dataChanged(const QHash<QByteArray, QVariant>& current,
 395                                   const QSet<QByteArray>& roles)
 396 {
 397     Q_UNUSED(current);
 398     Q_UNUSED(roles);
 399 }
 400
 401 void KItemListWidget::visibleRolesChanged(const QList<QByteArray>& current,
 402                                           const QList<QByteArray>& previous)
 403 {
 404     Q_UNUSED(current);
 405     Q_UNUSED(previous);
 406 }
 407
 408 void KItemListWidget::columnWidthChanged(const QByteArray& role,
 409                                          qreal current,
 410                                          qreal previous)
 411 {
 412     Q_UNUSED(role);
 413     Q_UNUSED(current);
 414     Q_UNUSED(previous);
 415 }
 416
 417 void KItemListWidget::styleOptionChanged(const KItemListStyleOption& current,
 418                                          const KItemListStyleOption& previous)
 419 {
 420     Q_UNUSED(current);
 421     Q_UNUSED(previous);
 422 }
 423
 424 void KItemListWidget::currentChanged(bool current)
 425 {
 426     Q_UNUSED(current);
 427 }
 428
 429 void KItemListWidget::selectedChanged(bool selected)
 430 {
 431     Q_UNUSED(selected);
 432 }
 433
 434 void KItemListWidget::hoveredChanged(bool hovered)
 435 {
 436     Q_UNUSED(hovered);
 437 }
 438
 439 void KItemListWidget::alternateBackgroundChanged(bool enabled)
 440 {
 441     Q_UNUSED(enabled);
 442 }
 443
 444 void KItemListWidget::siblingsInformationChanged(const QBitArray& current, const QBitArray& previous)
 445 {
 446     Q_UNUSED(current);
 447     Q_UNUSED(previous);
 448 }
 449
 450 void KItemListWidget::editedRoleChanged(const QByteArray& current, const QByteArray& previous)
 451 {
 452     Q_UNUSED(current);
 453     Q_UNUSED(previous);
 454 }
 455
 456 void KItemListWidget::resizeEvent(QGraphicsSceneResizeEvent* event)
 457 {
 458     QGraphicsWidget::resizeEvent(event);
 459     clearHoverCache();
 460
 461     if (m_selectionToggle) {
 462         const QRectF& toggleRect = selectionToggleRect();
 463         m_selectionToggle->setPos(toggleRect.topLeft());
 464         m_selectionToggle->resize(toggleRect.size());
 465     }
 466 }
 467
 468 qreal KItemListWidget::hoverOpacity() const
 469 {
 470     return m_hoverOpacity;
 471 }
 472
 473 void KItemListWidget::slotHoverAnimationFinished()
 474 {
 475     if (!m_hovered && m_selectionToggle) {
 476         m_selectionToggle->deleteLater();
 477         m_selectionToggle = nullptr;
 478     }
 479 }
 480
 481 void KItemListWidget::initializeSelectionToggle()
 482 {
 483     Q_ASSERT(m_enabledSelectionToggle);
 484
 485     if (!m_selectionToggle) {
 486         m_selectionToggle = new KItemListSelectionToggle(this);
 487     }
 488
 489     const QRectF toggleRect = selectionToggleRect();
 490     m_selectionToggle->setPos(toggleRect.topLeft());
 491     m_selectionToggle->resize(toggleRect.size());
 492
 493     m_selectionToggle->setChecked(isSelected());
 494 }
 495
 496 void KItemListWidget::setHoverOpacity(qreal opacity)
 497 {
 498     m_hoverOpacity = opacity;
 499     if (m_selectionToggle) {
 500         m_selectionToggle->setOpacity(opacity);
 501     }
 502
 503     if (m_hoverOpacity <= 0.0) {
 504         delete m_hoverCache;
 505         m_hoverCache = nullptr;
 506     }
 507
 508     update();
 509 }
 510
 511 void KItemListWidget::clearHoverCache()
 512 {
 513     delete m_hoverCache;
 514     m_hoverCache = nullptr;
 515 }
 516
 517 void KItemListWidget::drawItemStyleOption(QPainter* painter, QWidget* widget, QStyle::State styleState)
 518 {
 519     QStyleOptionViewItem viewItemOption;
 520     viewItemOption.initFrom(widget);
 521     viewItemOption.state = styleState;
 522     viewItemOption.viewItemPosition = QStyleOptionViewItem::OnlyOne;
 523     viewItemOption.showDecorationSelected = true;
 524     viewItemOption.rect = selectionRect().toRect();
 525     widget->style()->drawPrimitive(QStyle::PE_PanelItemViewItem, &viewItemOption, painter, widget);
 526 }
 527