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     const KItemListStyleOption previous = m_styleOption;
 195     clearHoverCache();
 196     m_styleOption = option;
 197
 198     styleOptionChanged(option, previous);
 199     update();
 200 }
 201
 202 const KItemListStyleOption& KItemListWidget::styleOption() const
 203 {
 204     return m_styleOption;
 205 }
 206
 207 void KItemListWidget::setSelected(bool selected)
 208 {
 209     if (m_selected != selected) {
 210         m_selected = selected;
 211         if (m_selectionToggle) {
 212             m_selectionToggle->setChecked(selected);
 213         }
 214         selectedChanged(selected);
 215         update();
 216     }
 217 }
 218
 219 bool KItemListWidget::isSelected() const
 220 {
 221     return m_selected;
 222 }
 223
 224 void KItemListWidget::setCurrent(bool current)
 225 {
 226     if (m_current != current) {
 227         m_current = current;
 228         currentChanged(current);
 229         update();
 230     }
 231 }
 232
 233 bool KItemListWidget::isCurrent() const
 234 {
 235     return m_current;
 236 }
 237
 238 void KItemListWidget::setHovered(bool hovered)
 239 {
 240     if (hovered == m_hovered) {
 241         return;
 242     }
 243
 244     m_hovered = hovered;
 245
 246     if (!m_hoverAnimation) {
 247         m_hoverAnimation = new QPropertyAnimation(this, "hoverOpacity", this);
 248         const int duration = style()->styleHint(QStyle::SH_Widget_Animate) ? 200 : 1;
 249         m_hoverAnimation->setDuration(duration);
 250         connect(m_hoverAnimation, &QPropertyAnimation::finished, this, &KItemListWidget::slotHoverAnimationFinished);
 251     }
 252     m_hoverAnimation->stop();
 253
 254     if (hovered) {
 255         const qreal startValue = qMax(hoverOpacity(), qreal(0.1));
 256         m_hoverAnimation->setStartValue(startValue);
 257         m_hoverAnimation->setEndValue(1.0);
 258         if (m_enabledSelectionToggle && !(QApplication::mouseButtons() & Qt::LeftButton)) {
 259             initializeSelectionToggle();
 260         }
 261     } else {
 262         m_hoverAnimation->setStartValue(hoverOpacity());
 263         m_hoverAnimation->setEndValue(0.0);
 264     }
 265
 266     m_hoverAnimation->start();
 267
 268     hoveredChanged(hovered);
 269     update();
 270 }
 271
 272 bool KItemListWidget::isHovered() const
 273 {
 274     return m_hovered;
 275 }
 276
 277 void KItemListWidget::setHoverPosition(const QPointF& pos)
 278 {
 279     if (m_selectionToggle) {
 280         m_selectionToggle->setHovered(selectionToggleRect().contains(pos));
 281     }
 282 }
 283
 284 void KItemListWidget::setAlternateBackground(bool enable)
 285 {
 286     if (m_alternateBackground != enable) {
 287         m_alternateBackground = enable;
 288         alternateBackgroundChanged(enable);
 289         update();
 290     }
 291 }
 292
 293 bool KItemListWidget::alternateBackground() const
 294 {
 295     return m_alternateBackground;
 296 }
 297
 298 void KItemListWidget::setEnabledSelectionToggle(bool enable)
 299 {
 300     if (m_enabledSelectionToggle != enable) {
 301         m_enabledSelectionToggle = enable;
 302         update();
 303     }
 304 }
 305
 306 bool KItemListWidget::enabledSelectionToggle() const
 307 {
 308     return m_enabledSelectionToggle;
 309 }
 310
 311 void KItemListWidget::setSiblingsInformation(const QBitArray& siblings)
 312 {
 313     const QBitArray previous = m_siblingsInfo;
 314     m_siblingsInfo = siblings;
 315     siblingsInformationChanged(m_siblingsInfo, previous);
 316     update();
 317 }
 318
 319 QBitArray KItemListWidget::siblingsInformation() const
 320 {
 321     return m_siblingsInfo;
 322 }
 323
 324 void KItemListWidget::setEditedRole(const QByteArray& role)
 325 {
 326     if (m_editedRole != role) {
 327         const QByteArray previous = m_editedRole;
 328         m_editedRole = role;
 329         editedRoleChanged(role, previous);
 330     }
 331 }
 332
 333 QByteArray KItemListWidget::editedRole() const
 334 {
 335     return m_editedRole;
 336 }
 337
 338 bool KItemListWidget::contains(const QPointF& point) const
 339 {
 340     if (!QGraphicsWidget::contains(point)) {
 341         return false;
 342     }
 343
 344     return iconRect().contains(point) ||
 345            textRect().contains(point) ||
 346            expansionToggleRect().contains(point) ||
 347            selectionToggleRect().contains(point);
 348 }
 349
 350 QRectF KItemListWidget::textFocusRect() const
 351 {
 352     return textRect();
 353 }
 354
 355 QRectF KItemListWidget::selectionToggleRect() const
 356 {
 357     return QRectF();
 358 }
 359
 360 QRectF KItemListWidget::expansionToggleRect() const
 361 {
 362     return QRectF();
 363 }
 364
 365 QPixmap KItemListWidget::createDragPixmap(const QStyleOptionGraphicsItem* option,
 366                                           QWidget* widget)
 367 {
 368     QPixmap pixmap(size().toSize() * widget->devicePixelRatio());
 369     pixmap.setDevicePixelRatio(widget->devicePixelRatio());
 370     pixmap.fill(Qt::transparent);
 371
 372     QPainter painter(&pixmap);
 373
 374     const bool oldAlternateBackground = m_alternateBackground;
 375     const bool wasSelected = m_selected;
 376     const bool wasHovered = m_hovered;
 377
 378     setAlternateBackground(false);
 379     setSelected(false);
 380     setHovered(false);
 381
 382     paint(&painter, option, widget);
 383
 384     setAlternateBackground(oldAlternateBackground);
 385     setSelected(wasSelected);
 386     setHovered(wasHovered);
 387
 388     return pixmap;
 389 }
 390
 391 void KItemListWidget::dataChanged(const QHash<QByteArray, QVariant>& current,
 392                                   const QSet<QByteArray>& roles)
 393 {
 394     Q_UNUSED(current);
 395     Q_UNUSED(roles);
 396 }
 397
 398 void KItemListWidget::visibleRolesChanged(const QList<QByteArray>& current,
 399                                           const QList<QByteArray>& previous)
 400 {
 401     Q_UNUSED(current);
 402     Q_UNUSED(previous);
 403 }
 404
 405 void KItemListWidget::columnWidthChanged(const QByteArray& role,
 406                                          qreal current,
 407                                          qreal previous)
 408 {
 409     Q_UNUSED(role);
 410     Q_UNUSED(current);
 411     Q_UNUSED(previous);
 412 }
 413
 414 void KItemListWidget::styleOptionChanged(const KItemListStyleOption& current,
 415                                          const KItemListStyleOption& previous)
 416 {
 417     Q_UNUSED(current);
 418     Q_UNUSED(previous);
 419 }
 420
 421 void KItemListWidget::currentChanged(bool current)
 422 {
 423     Q_UNUSED(current);
 424 }
 425
 426 void KItemListWidget::selectedChanged(bool selected)
 427 {
 428     Q_UNUSED(selected);
 429 }
 430
 431 void KItemListWidget::hoveredChanged(bool hovered)
 432 {
 433     Q_UNUSED(hovered);
 434 }
 435
 436 void KItemListWidget::alternateBackgroundChanged(bool enabled)
 437 {
 438     Q_UNUSED(enabled);
 439 }
 440
 441 void KItemListWidget::siblingsInformationChanged(const QBitArray& current, const QBitArray& previous)
 442 {
 443     Q_UNUSED(current);
 444     Q_UNUSED(previous);
 445 }
 446
 447 void KItemListWidget::editedRoleChanged(const QByteArray& current, const QByteArray& previous)
 448 {
 449     Q_UNUSED(current);
 450     Q_UNUSED(previous);
 451 }
 452
 453 void KItemListWidget::resizeEvent(QGraphicsSceneResizeEvent* event)
 454 {
 455     QGraphicsWidget::resizeEvent(event);
 456     clearHoverCache();
 457
 458     if (m_selectionToggle) {
 459         const QRectF& toggleRect = selectionToggleRect();
 460         m_selectionToggle->setPos(toggleRect.topLeft());
 461         m_selectionToggle->resize(toggleRect.size());
 462     }
 463 }
 464
 465 qreal KItemListWidget::hoverOpacity() const
 466 {
 467     return m_hoverOpacity;
 468 }
 469
 470 void KItemListWidget::slotHoverAnimationFinished()
 471 {
 472     if (!m_hovered && m_selectionToggle) {
 473         m_selectionToggle->deleteLater();
 474         m_selectionToggle = nullptr;
 475     }
 476 }
 477
 478 void KItemListWidget::initializeSelectionToggle()
 479 {
 480     Q_ASSERT(m_enabledSelectionToggle);
 481
 482     if (!m_selectionToggle) {
 483         m_selectionToggle = new KItemListSelectionToggle(this);
 484     }
 485
 486     const QRectF toggleRect = selectionToggleRect();
 487     m_selectionToggle->setPos(toggleRect.topLeft());
 488     m_selectionToggle->resize(toggleRect.size());
 489
 490     m_selectionToggle->setChecked(isSelected());
 491 }
 492
 493 void KItemListWidget::setHoverOpacity(qreal opacity)
 494 {
 495     m_hoverOpacity = opacity;
 496     if (m_selectionToggle) {
 497         m_selectionToggle->setOpacity(opacity);
 498     }
 499
 500     if (m_hoverOpacity <= 0.0) {
 501         delete m_hoverCache;
 502         m_hoverCache = nullptr;
 503     }
 504
 505     update();
 506 }
 507
 508 void KItemListWidget::clearHoverCache()
 509 {
 510     delete m_hoverCache;
 511     m_hoverCache = nullptr;
 512 }
 513
 514 void KItemListWidget::drawItemStyleOption(QPainter* painter, QWidget* widget, QStyle::State styleState)
 515 {
 516     QStyleOptionViewItem viewItemOption;
 517     viewItemOption.initFrom(widget);
 518     viewItemOption.state = styleState;
 519     viewItemOption.viewItemPosition = QStyleOptionViewItem::OnlyOne;
 520     viewItemOption.showDecorationSelected = true;
 521     viewItemOption.rect = selectionRect().toRect();
 522     widget->style()->drawPrimitive(QStyle::PE_PanelItemViewItem, &viewItemOption, painter, widget);
 523 }
 524