src/kitemviews/private/kitemlistviewlayouter.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2011 by Peter Penz <peter.penz19@gmail.com>             *
   3  *                                                                         *
   4  *   This program is free software; you can redistribute it and/or modify  *
   5  *   it under the terms of the GNU General Public License as published by  *
   6  *   the Free Software Foundation; either version 2 of the License, or     *
   7  *   (at your option) any later version.                                   *
   8  *                                                                         *
   9  *   This program is distributed in the hope that it will be useful,       *
  10  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  11  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  12  *   GNU General Public License for more details.                          *
  13  *                                                                         *
  14  *   You should have received a copy of the GNU General Public License     *
  15  *   along with this program; if not, write to the                         *
  16  *   Free Software Foundation, Inc.,                                       *
  17  *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA            *
  18  ***************************************************************************/
  19
  20 #include "kitemlistviewlayouter.h"
  21
  22 #include <kitemviews/kitemmodelbase.h>
  23 #include "kitemlistsizehintresolver.h"
  24
  25 #include <KDebug>
  26
  27 // #define KITEMLISTVIEWLAYOUTER_DEBUG
  28
  29 KItemListViewLayouter::KItemListViewLayouter(QObject* parent) :
  30     QObject(parent),
  31     m_dirty(true),
  32     m_visibleIndexesDirty(true),
  33     m_scrollOrientation(Qt::Vertical),
  34     m_size(),
  35     m_itemSize(128, 128),
  36     m_itemMargin(),
  37     m_headerHeight(0),
  38     m_model(0),
  39     m_sizeHintResolver(0),
  40     m_scrollOffset(0),
  41     m_maximumScrollOffset(0),
  42     m_itemOffset(0),
  43     m_maximumItemOffset(0),
  44     m_firstVisibleIndex(-1),
  45     m_lastVisibleIndex(-1),
  46     m_columnWidth(0),
  47     m_xPosInc(0),
  48     m_columnCount(0),
  49     m_groupItemIndexes(),
  50     m_groupHeaderHeight(0),
  51     m_groupHeaderMargin(0),
  52     m_itemInfos()
  53 {
  54 }
  55
  56 KItemListViewLayouter::~KItemListViewLayouter()
  57 {
  58 }
  59
  60 void KItemListViewLayouter::setScrollOrientation(Qt::Orientation orientation)
  61 {
  62     if (m_scrollOrientation != orientation) {
  63         m_scrollOrientation = orientation;
  64         m_dirty = true;
  65     }
  66 }
  67
  68 Qt::Orientation KItemListViewLayouter::scrollOrientation() const
  69 {
  70     return m_scrollOrientation;
  71 }
  72
  73 void KItemListViewLayouter::setSize(const QSizeF& size)
  74 {
  75     if (m_size != size) {
  76         if (m_scrollOrientation == Qt::Vertical) {
  77             if (m_size.width() != size.width()) {
  78                 m_dirty = true;
  79             }
  80         } else if (m_size.height() != size.height()) {
  81             m_dirty = true;
  82         }
  83
  84         m_size = size;
  85         m_visibleIndexesDirty = true;
  86     }
  87 }
  88
  89 QSizeF KItemListViewLayouter::size() const
  90 {
  91     return m_size;
  92 }
  93
  94 void KItemListViewLayouter::setItemSize(const QSizeF& size)
  95 {
  96     if (m_itemSize != size) {
  97         m_itemSize = size;
  98         m_dirty = true;
  99     }
 100 }
 101
 102 QSizeF KItemListViewLayouter::itemSize() const
 103 {
 104     return m_itemSize;
 105 }
 106
 107 void KItemListViewLayouter::setItemMargin(const QSizeF& margin)
 108 {
 109     if (m_itemMargin != margin) {
 110         m_itemMargin = margin;
 111         m_dirty = true;
 112     }
 113 }
 114
 115 QSizeF KItemListViewLayouter::itemMargin() const
 116 {
 117     return m_itemMargin;
 118 }
 119
 120 void KItemListViewLayouter::setHeaderHeight(qreal height)
 121 {
 122     if (m_headerHeight != height) {
 123         m_headerHeight = height;
 124         m_dirty = true;
 125     }
 126 }
 127
 128 qreal KItemListViewLayouter::headerHeight() const
 129 {
 130     return m_headerHeight;
 131 }
 132
 133 void KItemListViewLayouter::setGroupHeaderHeight(qreal height)
 134 {
 135     if (m_groupHeaderHeight != height) {
 136         m_groupHeaderHeight = height;
 137         m_dirty = true;
 138     }
 139 }
 140
 141 qreal KItemListViewLayouter::groupHeaderHeight() const
 142 {
 143     return m_groupHeaderHeight;
 144 }
 145
 146 void KItemListViewLayouter::setGroupHeaderMargin(qreal margin)
 147 {
 148     if (m_groupHeaderMargin != margin) {
 149         m_groupHeaderMargin = margin;
 150         m_dirty = true;
 151     }
 152 }
 153
 154 qreal KItemListViewLayouter::groupHeaderMargin() const
 155 {
 156     return m_groupHeaderMargin;
 157 }
 158
 159 void KItemListViewLayouter::setScrollOffset(qreal offset)
 160 {
 161     if (m_scrollOffset != offset) {
 162         m_scrollOffset = offset;
 163         m_visibleIndexesDirty = true;
 164     }
 165 }
 166
 167 qreal KItemListViewLayouter::scrollOffset() const
 168 {
 169     return m_scrollOffset;
 170 }
 171
 172 qreal KItemListViewLayouter::maximumScrollOffset() const
 173 {
 174     const_cast<KItemListViewLayouter*>(this)->doLayout();
 175     return m_maximumScrollOffset;
 176 }
 177
 178 void KItemListViewLayouter::setItemOffset(qreal offset)
 179 {
 180     if (m_itemOffset != offset) {
 181         m_itemOffset = offset;
 182         m_visibleIndexesDirty = true;
 183     }
 184 }
 185
 186 qreal KItemListViewLayouter::itemOffset() const
 187 {
 188     return m_itemOffset;
 189 }
 190
 191 qreal KItemListViewLayouter::maximumItemOffset() const
 192 {
 193     const_cast<KItemListViewLayouter*>(this)->doLayout();
 194     return m_maximumItemOffset;
 195 }
 196
 197 void KItemListViewLayouter::setModel(const KItemModelBase* model)
 198 {
 199     if (m_model != model) {
 200         m_model = model;
 201         m_dirty = true;
 202     }
 203 }
 204
 205 const KItemModelBase* KItemListViewLayouter::model() const
 206 {
 207     return m_model;
 208 }
 209
 210 void KItemListViewLayouter::setSizeHintResolver(const KItemListSizeHintResolver* sizeHintResolver)
 211 {
 212     if (m_sizeHintResolver != sizeHintResolver) {
 213         m_sizeHintResolver = sizeHintResolver;
 214         m_dirty = true;
 215     }
 216 }
 217
 218 const KItemListSizeHintResolver* KItemListViewLayouter::sizeHintResolver() const
 219 {
 220     return m_sizeHintResolver;
 221 }
 222
 223 int KItemListViewLayouter::firstVisibleIndex() const
 224 {
 225     const_cast<KItemListViewLayouter*>(this)->doLayout();
 226     return m_firstVisibleIndex;
 227 }
 228
 229 int KItemListViewLayouter::lastVisibleIndex() const
 230 {
 231     const_cast<KItemListViewLayouter*>(this)->doLayout();
 232     return m_lastVisibleIndex;
 233 }
 234
 235 QRectF KItemListViewLayouter::itemRect(int index) const
 236 {
 237     const_cast<KItemListViewLayouter*>(this)->doLayout();
 238     if (index < 0 || index >= m_itemInfos.count()) {
 239         return QRectF();
 240     }
 241
 242     if (m_scrollOrientation == Qt::Horizontal) {
 243         // Rotate the logical direction which is always vertical by 90°
 244         // to get the physical horizontal direction
 245         const QRectF& b = m_itemInfos[index].rect;
 246         QRectF bounds(b.y(), b.x(), b.height(), b.width());
 247         QPointF pos = bounds.topLeft();
 248         pos.rx() -= m_scrollOffset;
 249         bounds.moveTo(pos);
 250         return bounds;
 251     }
 252
 253     QRectF bounds = m_itemInfos[index].rect;
 254     bounds.moveTo(bounds.topLeft() - QPointF(m_itemOffset, m_scrollOffset));
 255     return bounds;
 256 }
 257
 258 QRectF KItemListViewLayouter::groupHeaderRect(int index) const
 259 {
 260     const_cast<KItemListViewLayouter*>(this)->doLayout();
 261
 262     const QRectF firstItemRect = itemRect(index);
 263     QPointF pos = firstItemRect.topLeft();
 264     if (pos.isNull()) {
 265         return QRectF();
 266     }
 267
 268     QSizeF size;
 269     if (m_scrollOrientation == Qt::Vertical) {
 270         pos.rx() = 0;
 271         pos.ry() -= m_groupHeaderHeight;
 272         size = QSizeF(m_size.width(), m_groupHeaderHeight);
 273     } else {
 274         pos.rx() -= m_itemMargin.width();
 275         pos.ry() = 0;
 276
 277         // Determine the maximum width used in the
 278         // current column. As the scroll-direction is
 279         // Qt::Horizontal and m_itemRects is accessed directly,
 280         // the logical height represents the visual width.
 281         qreal width = minimumGroupHeaderWidth();
 282         const qreal y = m_itemInfos[index].rect.y();
 283         const int maxIndex = m_itemInfos.count() - 1;
 284         while (index <= maxIndex) {
 285             QRectF bounds = m_itemInfos[index].rect;
 286             if (bounds.y() != y) {
 287                 break;
 288             }
 289
 290             if (bounds.height() > width) {
 291                 width = bounds.height();
 292             }
 293
 294             ++index;
 295         }
 296
 297         size = QSizeF(width, m_size.height());
 298     }
 299     return QRectF(pos, size);
 300 }
 301
 302 int KItemListViewLayouter::itemColumn(int index) const
 303 {
 304     const_cast<KItemListViewLayouter*>(this)->doLayout();
 305     if (index < 0 || index >= m_itemInfos.count()) {
 306         return -1;
 307     }
 308
 309     return (m_scrollOrientation == Qt::Vertical)
 310             ? m_itemInfos[index].column
 311             : m_itemInfos[index].row;
 312 }
 313
 314 int KItemListViewLayouter::itemRow(int index) const
 315 {
 316     const_cast<KItemListViewLayouter*>(this)->doLayout();
 317     if (index < 0 || index >= m_itemInfos.count()) {
 318         return -1;
 319     }
 320
 321     return (m_scrollOrientation == Qt::Vertical)
 322             ? m_itemInfos[index].row
 323             : m_itemInfos[index].column;
 324 }
 325
 326 int KItemListViewLayouter::maximumVisibleItems() const
 327 {
 328     const_cast<KItemListViewLayouter*>(this)->doLayout();
 329
 330     const int height = static_cast<int>(m_size.height());
 331     const int rowHeight = static_cast<int>(m_itemSize.height());
 332     int rows = height / rowHeight;
 333     if (height % rowHeight != 0) {
 334         ++rows;
 335     }
 336
 337     return rows * m_columnCount;
 338 }
 339
 340 bool KItemListViewLayouter::isFirstGroupItem(int itemIndex) const
 341 {
 342     const_cast<KItemListViewLayouter*>(this)->doLayout();
 343     return m_groupItemIndexes.contains(itemIndex);
 344 }
 345
 346 void KItemListViewLayouter::markAsDirty()
 347 {
 348     m_dirty = true;
 349 }
 350
 351
 352 #ifndef QT_NO_DEBUG
 353     bool KItemListViewLayouter::isDirty()
 354     {
 355         return m_dirty;
 356     }
 357 #endif
 358
 359 void KItemListViewLayouter::doLayout()
 360 {
 361     if (m_dirty) {
 362 #ifdef KITEMLISTVIEWLAYOUTER_DEBUG
 363         QElapsedTimer timer;
 364         timer.start();
 365 #endif
 366         m_visibleIndexesDirty = true;
 367
 368         QSizeF itemSize = m_itemSize;
 369         QSizeF itemMargin = m_itemMargin;
 370         QSizeF size = m_size;
 371
 372         const bool grouped = createGroupHeaders();
 373
 374         const bool horizontalScrolling = (m_scrollOrientation == Qt::Horizontal);
 375         if (horizontalScrolling) {
 376             // Flip everything so that the layout logically can work like having
 377             // a vertical scrolling
 378             itemSize.transpose();
 379             itemMargin.transpose();
 380             size.transpose();
 381
 382             if (grouped) {
 383                 // In the horizontal scrolling case all groups are aligned
 384                 // at the top, which decreases the available height. For the
 385                 // flipped data this means that the width must be decreased.
 386                 size.rwidth() -= m_groupHeaderHeight;
 387             }
 388         }
 389
 390         m_columnWidth = itemSize.width() + itemMargin.width();
 391         const qreal widthForColumns = size.width() - itemMargin.width();
 392         m_columnCount = qMax(1, int(widthForColumns / m_columnWidth));
 393         m_xPosInc = itemMargin.width();
 394
 395         const int itemCount = m_model->count();
 396         if (itemCount > m_columnCount && m_columnWidth >= 32) {
 397             // Apply the unused width equally to each column
 398             const qreal unusedWidth = widthForColumns - m_columnCount * m_columnWidth;
 399             if (unusedWidth > 0) {
 400                 const qreal columnInc = unusedWidth / (m_columnCount + 1);
 401                 m_columnWidth += columnInc;
 402                 m_xPosInc += columnInc;
 403             }
 404         }
 405
 406         m_itemInfos.resize(itemCount);
 407
 408         qreal y = m_headerHeight + itemMargin.height();
 409         int row = 0;
 410
 411         int index = 0;
 412         while (index < itemCount) {
 413             qreal x = m_xPosInc;
 414             qreal maxItemHeight = itemSize.height();
 415
 416             if (grouped) {
 417                 if (horizontalScrolling) {
 418                     // All group headers will always be aligned on the top and not
 419                     // flipped like the other properties
 420                     x += m_groupHeaderHeight;
 421                 }
 422
 423                 if (m_groupItemIndexes.contains(index)) {
 424                     // The item is the first item of a group.
 425                     // Increase the y-position to provide space
 426                     // for the group header.
 427                     if (index > 0) {
 428                         // Only add a margin if there has been added another
 429                         // group already before
 430                         y += m_groupHeaderMargin;
 431                     } else if (!horizontalScrolling) {
 432                         // The first group header should be aligned on top
 433                         y -= itemMargin.height();
 434                     }
 435
 436                     if (!horizontalScrolling) {
 437                         y += m_groupHeaderHeight;
 438                     }
 439                 }
 440             }
 441
 442             int column = 0;
 443             while (index < itemCount && column < m_columnCount) {
 444                 qreal requiredItemHeight = itemSize.height();
 445                 if (m_sizeHintResolver) {
 446                     const QSizeF sizeHint = m_sizeHintResolver->sizeHint(index);
 447                     const qreal sizeHintHeight = horizontalScrolling ? sizeHint.width() : sizeHint.height();
 448                     if (sizeHintHeight > requiredItemHeight) {
 449                         requiredItemHeight = sizeHintHeight;
 450                     }
 451                 }
 452
 453                 ItemInfo& itemInfo = m_itemInfos[index];
 454                 itemInfo.rect = QRectF(x, y, itemSize.width(), requiredItemHeight);
 455                 itemInfo.column = column;
 456                 itemInfo.row = row;
 457
 458                 if (grouped && horizontalScrolling) {
 459                     // When grouping is enabled in the horizontal mode, the header alignment
 460                     // looks like this:
 461                     //   Header-1 Header-2 Header-3
 462                     //   Item 1   Item 4   Item 7
 463                     //   Item 2   Item 5   Item 8
 464                     //   Item 3   Item 6   Item 9
 465                     // In this case 'requiredItemHeight' represents the column-width. We don't
 466                     // check the content of the header in the layouter to determine the required
 467                     // width, hence assure that at least a minimal width of 15 characters is given
 468                     // (in average a character requires the halve width of the font height).
 469                     //
 470                     // TODO: Let the group headers provide a minimum width and respect this width here
 471                     const qreal headerWidth = minimumGroupHeaderWidth();
 472                     if (requiredItemHeight < headerWidth) {
 473                         requiredItemHeight = headerWidth;
 474                     }
 475                 }
 476
 477                 maxItemHeight = qMax(maxItemHeight, requiredItemHeight);
 478                 x += m_columnWidth;
 479                 ++index;
 480                 ++column;
 481
 482                 if (grouped && m_groupItemIndexes.contains(index)) {
 483                     // The item represents the first index of a group
 484                     // and must aligned in the first column
 485                     break;
 486                 }
 487             }
 488
 489             y += maxItemHeight + itemMargin.height();
 490             ++row;
 491         }
 492
 493         if (itemCount > 0) {
 494             m_maximumScrollOffset = y;
 495             m_maximumItemOffset = m_columnCount * m_columnWidth;
 496         } else {
 497             m_maximumScrollOffset = 0;
 498             m_maximumItemOffset = 0;
 499         }
 500
 501 #ifdef KITEMLISTVIEWLAYOUTER_DEBUG
 502         kDebug() << "[TIME] doLayout() for " << m_model->count() << "items:" << timer.elapsed();
 503 #endif
 504         m_dirty = false;
 505     }
 506
 507     updateVisibleIndexes();
 508 }
 509
 510 void KItemListViewLayouter::updateVisibleIndexes()
 511 {
 512     if (!m_visibleIndexesDirty) {
 513         return;
 514     }
 515
 516     Q_ASSERT(!m_dirty);
 517
 518     if (m_model->count() <= 0) {
 519         m_firstVisibleIndex = -1;
 520         m_lastVisibleIndex = -1;
 521         m_visibleIndexesDirty = false;
 522         return;
 523     }
 524
 525     const int maxIndex = m_model->count() - 1;
 526
 527     // Calculate the first visible index that is fully visible
 528     int min = 0;
 529     int max = maxIndex;
 530     int mid = 0;
 531     do {
 532         mid = (min + max) / 2;
 533         if (m_itemInfos[mid].rect.top() < m_scrollOffset) {
 534             min = mid + 1;
 535         } else {
 536             max = mid - 1;
 537         }
 538     } while (min <= max);
 539
 540     if (mid > 0) {
 541         // Include the row before the first fully visible index, as it might
 542         // be partly visible
 543         if (m_itemInfos[mid].rect.top() >= m_scrollOffset) {
 544             --mid;
 545             Q_ASSERT(m_itemInfos[mid].rect.top() < m_scrollOffset);
 546         }
 547
 548         const qreal rowTop = m_itemInfos[mid].rect.top();
 549         while (mid > 0 && m_itemInfos[mid - 1].rect.top() == rowTop) {
 550             --mid;
 551         }
 552     }
 553     m_firstVisibleIndex = mid;
 554
 555     // Calculate the last visible index that is (at least partly) visible
 556     const int visibleHeight = (m_scrollOrientation == Qt::Horizontal) ? m_size.width() : m_size.height();
 557     qreal bottom = m_scrollOffset + visibleHeight;
 558     if (m_model->groupedSorting()) {
 559         bottom += m_groupHeaderHeight;
 560     }
 561
 562     min = m_firstVisibleIndex;
 563     max = maxIndex;
 564     do {
 565         mid = (min + max) / 2;
 566         if (m_itemInfos[mid].rect.y() <= bottom) {
 567             min = mid + 1;
 568         } else {
 569             max = mid - 1;
 570         }
 571     } while (min <= max);
 572
 573     while (mid > 0 && m_itemInfos[mid].rect.y() > bottom) {
 574         --mid;
 575     }
 576     m_lastVisibleIndex = mid;
 577
 578     m_visibleIndexesDirty = false;
 579 }
 580
 581 bool KItemListViewLayouter::createGroupHeaders()
 582 {
 583     if (!m_model->groupedSorting()) {
 584         return false;
 585     }
 586
 587     m_groupItemIndexes.clear();
 588
 589     const QList<QPair<int, QVariant> > groups = m_model->groups();
 590     if (groups.isEmpty()) {
 591         return false;
 592     }
 593
 594     for (int i = 0; i < groups.count(); ++i) {
 595         const int firstItemIndex = groups.at(i).first;
 596         m_groupItemIndexes.insert(firstItemIndex);
 597     }
 598
 599     return true;
 600 }
 601
 602 qreal KItemListViewLayouter::minimumGroupHeaderWidth() const
 603 {
 604     return 100;
 605 }
 606
 607 #include "kitemlistviewlayouter.moc"