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         int rowCount = itemCount / m_columnCount;
 407         if (itemCount % m_columnCount != 0) {
 408             ++rowCount;
 409         }
 410
 411         m_itemInfos.resize(itemCount);
 412
 413         qreal y = m_headerHeight + itemMargin.height();
 414         int row = 0;
 415
 416         int index = 0;
 417         while (index < itemCount) {
 418             qreal x = m_xPosInc;
 419             qreal maxItemHeight = itemSize.height();
 420
 421             if (grouped) {
 422                 if (horizontalScrolling) {
 423                     // All group headers will always be aligned on the top and not
 424                     // flipped like the other properties
 425                     x += m_groupHeaderHeight;
 426                 }
 427
 428                 if (m_groupItemIndexes.contains(index)) {
 429                     // The item is the first item of a group.
 430                     // Increase the y-position to provide space
 431                     // for the group header.
 432                     if (index > 0) {
 433                         // Only add a margin if there has been added another
 434                         // group already before
 435                         y += m_groupHeaderMargin;
 436                     } else if (!horizontalScrolling) {
 437                         // The first group header should be aligned on top
 438                         y -= itemMargin.height();
 439                     }
 440
 441                     if (!horizontalScrolling) {
 442                         y += m_groupHeaderHeight;
 443                     }
 444                 }
 445             }
 446
 447             int column = 0;
 448             while (index < itemCount && column < m_columnCount) {
 449                 qreal requiredItemHeight = itemSize.height();
 450                 if (m_sizeHintResolver) {
 451                     const QSizeF sizeHint = m_sizeHintResolver->sizeHint(index);
 452                     const qreal sizeHintHeight = horizontalScrolling ? sizeHint.width() : sizeHint.height();
 453                     if (sizeHintHeight > requiredItemHeight) {
 454                         requiredItemHeight = sizeHintHeight;
 455                     }
 456                 }
 457
 458                 ItemInfo& itemInfo = m_itemInfos[index];
 459                 itemInfo.rect = QRectF(x, y, itemSize.width(), requiredItemHeight);
 460                 itemInfo.column = column;
 461                 itemInfo.row = row;
 462
 463                 if (grouped && horizontalScrolling) {
 464                     // When grouping is enabled in the horizontal mode, the header alignment
 465                     // looks like this:
 466                     //   Header-1 Header-2 Header-3
 467                     //   Item 1   Item 4   Item 7
 468                     //   Item 2   Item 5   Item 8
 469                     //   Item 3   Item 6   Item 9
 470                     // In this case 'requiredItemHeight' represents the column-width. We don't
 471                     // check the content of the header in the layouter to determine the required
 472                     // width, hence assure that at least a minimal width of 15 characters is given
 473                     // (in average a character requires the halve width of the font height).
 474                     //
 475                     // TODO: Let the group headers provide a minimum width and respect this width here
 476                     const qreal headerWidth = minimumGroupHeaderWidth();
 477                     if (requiredItemHeight < headerWidth) {
 478                         requiredItemHeight = headerWidth;
 479                     }
 480                 }
 481
 482                 maxItemHeight = qMax(maxItemHeight, requiredItemHeight);
 483                 x += m_columnWidth;
 484                 ++index;
 485                 ++column;
 486
 487                 if (grouped && m_groupItemIndexes.contains(index)) {
 488                     // The item represents the first index of a group
 489                     // and must aligned in the first column
 490                     break;
 491                 }
 492             }
 493
 494             y += maxItemHeight + itemMargin.height();
 495             ++row;
 496         }
 497
 498         if (itemCount > 0) {
 499             // Calculate the maximum y-range of the last row for m_maximumScrollOffset
 500             m_maximumScrollOffset = m_itemInfos.last().rect.bottom();
 501             const qreal rowY = m_itemInfos.last().rect.y();
 502
 503             int index = m_itemInfos.count() - 2;
 504             while (index >= 0 && m_itemInfos[index].rect.bottom() >= rowY) {
 505                 m_maximumScrollOffset = qMax(m_maximumScrollOffset, m_itemInfos[index].rect.bottom());
 506                 --index;
 507             }
 508
 509             m_maximumScrollOffset += itemMargin.height();
 510
 511             m_maximumItemOffset = m_columnCount * m_columnWidth;
 512         } else {
 513             m_maximumScrollOffset = 0;
 514             m_maximumItemOffset = 0;
 515         }
 516
 517 #ifdef KITEMLISTVIEWLAYOUTER_DEBUG
 518         kDebug() << "[TIME] doLayout() for " << m_model->count() << "items:" << timer.elapsed();
 519 #endif
 520         m_dirty = false;
 521     }
 522
 523     updateVisibleIndexes();
 524 }
 525
 526 void KItemListViewLayouter::updateVisibleIndexes()
 527 {
 528     if (!m_visibleIndexesDirty) {
 529         return;
 530     }
 531
 532     Q_ASSERT(!m_dirty);
 533
 534     if (m_model->count() <= 0) {
 535         m_firstVisibleIndex = -1;
 536         m_lastVisibleIndex = -1;
 537         m_visibleIndexesDirty = false;
 538         return;
 539     }
 540
 541     const int maxIndex = m_model->count() - 1;
 542
 543     // Calculate the first visible index that is fully visible
 544     int min = 0;
 545     int max = maxIndex;
 546     int mid = 0;
 547     do {
 548         mid = (min + max) / 2;
 549         if (m_itemInfos[mid].rect.top() < m_scrollOffset) {
 550             min = mid + 1;
 551         } else {
 552             max = mid - 1;
 553         }
 554     } while (min <= max);
 555
 556     if (mid > 0) {
 557         // Include the row before the first fully visible index, as it might
 558         // be partly visible
 559         if (m_itemInfos[mid].rect.top() >= m_scrollOffset) {
 560             --mid;
 561             Q_ASSERT(m_itemInfos[mid].rect.top() < m_scrollOffset);
 562         }
 563
 564         const qreal rowTop = m_itemInfos[mid].rect.top();
 565         while (mid > 0 && m_itemInfos[mid - 1].rect.top() == rowTop) {
 566             --mid;
 567         }
 568     }
 569     m_firstVisibleIndex = mid;
 570
 571     // Calculate the last visible index that is (at least partly) visible
 572     const int visibleHeight = (m_scrollOrientation == Qt::Horizontal) ? m_size.width() : m_size.height();
 573     qreal bottom = m_scrollOffset + visibleHeight;
 574     if (m_model->groupedSorting()) {
 575         bottom += m_groupHeaderHeight;
 576     }
 577
 578     min = m_firstVisibleIndex;
 579     max = maxIndex;
 580     do {
 581         mid = (min + max) / 2;
 582         if (m_itemInfos[mid].rect.y() <= bottom) {
 583             min = mid + 1;
 584         } else {
 585             max = mid - 1;
 586         }
 587     } while (min <= max);
 588
 589     while (mid > 0 && m_itemInfos[mid].rect.y() > bottom) {
 590         --mid;
 591     }
 592     m_lastVisibleIndex = mid;
 593
 594     m_visibleIndexesDirty = false;
 595 }
 596
 597 bool KItemListViewLayouter::createGroupHeaders()
 598 {
 599     if (!m_model->groupedSorting()) {
 600         return false;
 601     }
 602
 603     m_groupItemIndexes.clear();
 604
 605     const QList<QPair<int, QVariant> > groups = m_model->groups();
 606     if (groups.isEmpty()) {
 607         return false;
 608     }
 609
 610     for (int i = 0; i < groups.count(); ++i) {
 611         const int firstItemIndex = groups.at(i).first;
 612         m_groupItemIndexes.insert(firstItemIndex);
 613     }
 614
 615     return true;
 616 }
 617
 618 qreal KItemListViewLayouter::minimumGroupHeaderWidth() const
 619 {
 620     return 100;
 621 }
 622
 623 #include "kitemlistviewlayouter.moc"