Timeline: Aggregate events when there are too many

With this change, if you have more than 1M events in a category, the ones with the shortest distances from one another will be drawn together, in grey instead of their respective colors. You can zoom in or hover-select them to see what they are. This greatly reduces memory consumption in those cases, but it requires some more book keeping in order to identify the events to be aggregated. Task-number: QTCREATORBUG-14983 Change-Id: If54d6d7efe5f720aa72003b2c307ea9562c911a1 Reviewed-by: Christian Kandeler <christian.kandeler@theqtcompany.com> Reviewed-by: Joerg Bornemann <joerg.bornemann@qt.io> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2016-05-06 16:58:22 +02:00
parent e6729c487d
commit 28c94c6b19
3 changed files with 435 additions and 138 deletions
--- a/src/libs/timeline/timelineitemsrenderpass.cpp
+++ b/src/libs/timeline/timelineitemsrenderpass.cpp
@@ -58,79 +58,195 @@ private:
 };

 struct TimelineItemsGeometry {
-    // Alternating nodes with with 7 and 4 vertices; and vertex indices are 16bit
-    static const int maxEventsPerNode = 0xffff * 2 / (7 + 4);
+    // Vertex indices are 16bit
+    static const int maxVerticesPerNode = 0xffff;

-    TimelineItemsGeometry() : usedVertices(0), node(0)
-    {
-        prevNode.set(0, TimelineModel::defaultRowHeight(), 0, 0, 0, 0, 0, 0);
-    }
+    enum VerticesPerEvent {
+        NoVertices = 0,
+        VerticesForSameHeight = 4,
+        VerticesForDifferentHeight = 6
+    };

+    TimelineItemsGeometry();
    uint usedVertices;
+
    OpaqueColoredPoint2DWithSize prevNode;
+    OpaqueColoredPoint2DWithSize currentNode;
+
    QSGGeometryNode *node;

+    void initNodes();
+
+    bool isEmpty() const;
+
    void allocate(QSGMaterial *material);
-    void addVertices(float itemTop);
-    void addEvent(float itemLeft, float itemTop, float itemWidth, float selectionId, uchar red,
-                  uchar green, uchar blue);
+    VerticesPerEvent addVertices();
+    void addEvent();
+
+    void nextNode(float itemLeft, float itemTop, float itemWidth = 0, float selectionId = 0,
+                  uchar red = 0, uchar green = 0, uchar blue = 0);
+    void updateCurrentNode(float itemRight, float itemTop);
+};
+
+class NodeUpdater {
+public:
+    NodeUpdater(const TimelineModel *model, const TimelineRenderState *parentState,
+                TimelineItemsRenderPassState *state, int indexFrom, int indexTo);
+    void run();
+
+private:
+    static const int s_maxNumItems = 1 << 20;
+    static const qint64 s_invalidTimestamp = 0xffffffffffffffffLL;
+
+    struct ItemDescription
+    {
+        uchar red;
+        uchar green;
+        uchar blue;
+
+        float width;
+        float left;
+        float right;
+
+        float top;
+        float selectionId;
+    };
+
+    int updateVertices(TimelineItemsGeometry &geometry, const QVarLengthArray<qint64> &distances,
+                       qint64 minDistance, float itemTop, int i) const;
+    void addEvent(TimelineItemsGeometry &geometry, const QVarLengthArray<qint64> &distances,
+                  qint64 minDistance, const ItemDescription &item, int i) const;
+    int updateNodes(const int from, const int to) const;
+
+    const TimelineModel *m_model;
+    const TimelineRenderState *m_parentState;
+    const int m_indexFrom;
+    const int m_indexTo;
+
+    TimelineItemsRenderPassState *m_state;
+    QVarLengthArray<qint64> m_collapsedDistances;
+    QVarLengthArray<qint64> m_expandedDistances;
+    qint64 m_minCollapsedDistance;
+    qint64 m_minExpandedDistance;
 };

 void OpaqueColoredPoint2DWithSize::set(float nx, float ny, float nw, float nh, float nid,
-                                       uchar nr, uchar ng, uchar nb) {
+                                       uchar nr, uchar ng, uchar nb, uchar d) {
    x = nx; y = ny; w = nw; h = nh; id = nid;
-    r = nr; g = ng, b = nb; a = 255;
+    r = nr; g = ng, b = nb; a = d;
 }

 float OpaqueColoredPoint2DWithSize::top() const
 {
-    return y;
+    return id < 0 ? (y / -id) : y;
 }

-void OpaqueColoredPoint2DWithSize::setTop(float top)
+void OpaqueColoredPoint2DWithSize::update(float nr, float ny)
 {
-    y = top;
+    if (id > -1)
+        id = -2;
+    else
+        --id;
+
+    y += ny;
+    w = nr - x;
 }

-void TimelineItemsGeometry::addEvent(float itemLeft, float itemTop, float itemWidth,
-                                                    float selectionId, uchar red, uchar green,
-                                                    uchar blue)
+OpaqueColoredPoint2DWithSize::Direction OpaqueColoredPoint2DWithSize::direction() const
 {
-    float rowHeight = TimelineModel::defaultRowHeight();
-    float itemHeight = rowHeight - itemTop;
-    OpaqueColoredPoint2DWithSize *v = OpaqueColoredPoint2DWithSize::fromVertexData(
-                node->geometry());
-    if (prevNode.top() == rowHeight) {
-        // "Z" form, bottom to top
-        v[usedVertices++].set(itemLeft, rowHeight, -itemWidth, -itemHeight, selectionId, red, green,
-                              blue);
-        v[usedVertices++].set(itemLeft + itemWidth, rowHeight, itemWidth, -itemHeight, selectionId,
-                              red, green, blue);
-        v[usedVertices++].set(itemLeft, itemTop, -itemWidth, itemHeight, selectionId, red, green,
-                              blue);
-        v[usedVertices++].set(itemLeft + itemWidth, itemTop, itemWidth, itemHeight, selectionId,
-                              red, green, blue);
-        prevNode = v[usedVertices - 1];
+    return static_cast<Direction>(a);
+}
+
+void OpaqueColoredPoint2DWithSize::setCommon(const OpaqueColoredPoint2DWithSize *master)
+{
+    a = 255;
+    if (master->id < 0) {
+        id = std::numeric_limits<float>::lowest();
+        r = g = b = 128;
    } else {
-        if (prevNode.top() != itemTop) {
-            // 2 extra vertices to degenerate the surplus triangles
-            v[usedVertices++] = prevNode;
-            v[usedVertices++].set(itemLeft, itemTop, -itemWidth, itemHeight, selectionId, red,
-                                  green, blue);
-        }
-        // "Z" form, top to bottom
-        v[usedVertices++].set(itemLeft, itemTop, -itemWidth, itemHeight, selectionId, red, green,
-                              blue);
-        v[usedVertices++].set(itemLeft + itemWidth, itemTop, itemWidth, itemHeight, selectionId,
-                              red, green, blue);
-        v[usedVertices++].set(itemLeft, rowHeight, - itemWidth, -itemHeight, selectionId, red,
-                              green, blue);
-        v[usedVertices++].set(itemLeft + itemWidth, rowHeight, itemWidth, -itemHeight, selectionId,
-                              red, green, blue);
-        prevNode = v[usedVertices - 1];
+        id = master->id;
+        r = master->r;
+        g = master->g;
+        b = master->b;
    }
+}

+void OpaqueColoredPoint2DWithSize::setLeft(const OpaqueColoredPoint2DWithSize *master)
+{
+    w = -master->w;
+    x = master->x;
+}

+void OpaqueColoredPoint2DWithSize::setRight(const OpaqueColoredPoint2DWithSize *master)
+{
+    w = master->w;
+    x = master->x + master->w;
+}
+
+void OpaqueColoredPoint2DWithSize::setTop(const OpaqueColoredPoint2DWithSize *master)
+{
+    y = master->id < 0 ? master->y / -master->id : master->y;
+    h = y - TimelineModel::defaultRowHeight();
+}
+
+void OpaqueColoredPoint2DWithSize::setBottom(const OpaqueColoredPoint2DWithSize *master)
+{
+    y = TimelineModel::defaultRowHeight();
+    h = TimelineModel::defaultRowHeight() - (master->id < 0 ? master->y / -master->id : master->y);
+}
+
+void OpaqueColoredPoint2DWithSize::setBottomLeft(const OpaqueColoredPoint2DWithSize *master)
+{
+    setCommon(master);
+    setLeft(master);
+    setBottom(master);
+}
+
+void OpaqueColoredPoint2DWithSize::setBottomRight(const OpaqueColoredPoint2DWithSize *master)
+{
+    setCommon(master);
+    setRight(master);
+    setBottom(master);
+}
+
+void OpaqueColoredPoint2DWithSize::setTopLeft(const OpaqueColoredPoint2DWithSize *master)
+{
+    setCommon(master);
+    setLeft(master);
+    setTop(master);
+}
+
+void OpaqueColoredPoint2DWithSize::setTopRight(const OpaqueColoredPoint2DWithSize *master)
+{
+    setCommon(master);
+    setRight(master);
+    setTop(master);
+}
+
+void TimelineItemsGeometry::addEvent()
+{
+    OpaqueColoredPoint2DWithSize *v =
+            OpaqueColoredPoint2DWithSize::fromVertexData(node->geometry());
+    switch (currentNode.direction()) {
+    case OpaqueColoredPoint2DWithSize::BottomToTop:
+        v[usedVertices++].setBottomLeft(&currentNode);
+        v[usedVertices++].setBottomRight(&currentNode);
+        v[usedVertices++].setTopLeft(&currentNode);
+        v[usedVertices++].setTopRight(&currentNode);
+        break;
+    case OpaqueColoredPoint2DWithSize::TopToBottom:
+        if (prevNode.top() != currentNode.top()) {
+            v[usedVertices++].setTopRight(&prevNode);
+            v[usedVertices++].setTopLeft(&currentNode);
+        }
+        v[usedVertices++].setTopLeft((&currentNode));
+        v[usedVertices++].setTopRight((&currentNode));
+        v[usedVertices++].setBottomLeft((&currentNode));
+        v[usedVertices++].setBottomRight((&currentNode));
+        break;
+    default:
+        break;
+    }
 }

 OpaqueColoredPoint2DWithSize *OpaqueColoredPoint2DWithSize::fromVertexData(QSGGeometry *geometry)
@@ -154,6 +270,25 @@ OpaqueColoredPoint2DWithSize *OpaqueColoredPoint2DWithSize::fromVertexData(QSGGe
    return static_cast<OpaqueColoredPoint2DWithSize *>(geometry->vertexData());
 }

+TimelineItemsGeometry::TimelineItemsGeometry() : usedVertices(0), node(0)
+{
+    initNodes();
+}
+
+void TimelineItemsGeometry::initNodes()
+{
+    currentNode.set(0, TimelineModel::defaultRowHeight(), 0, 0, 0, 0, 0, 0,
+                    OpaqueColoredPoint2DWithSize::InvalidDirection);
+    prevNode.set(0, TimelineModel::defaultRowHeight(), 0, 0, 0, 0, 0, 0,
+                 OpaqueColoredPoint2DWithSize::InvalidDirection);
+}
+
+bool TimelineItemsGeometry::isEmpty() const
+{
+    return usedVertices == 0 &&
+            currentNode.direction() == OpaqueColoredPoint2DWithSize::InvalidDirection;
+}
+
 void TimelineItemsGeometry::allocate(QSGMaterial *material)
 {
    QSGGeometry *geometry = new QSGGeometry(OpaqueColoredPoint2DWithSize::attributes(),
@@ -165,85 +300,55 @@ void TimelineItemsGeometry::allocate(QSGMaterial *material)
    node->setFlag(QSGNode::OwnsGeometry, true);
    node->setMaterial(material);
    usedVertices = 0;
-    prevNode.set(0, TimelineModel::defaultRowHeight(), 0, 0, 0, 0, 0, 0);
+    initNodes();
 }

-void TimelineItemsGeometry::addVertices(float itemTop)
+TimelineItemsGeometry::VerticesPerEvent TimelineItemsGeometry::addVertices()
 {
-    if (prevNode.top() == TimelineModel::defaultRowHeight()) {
-        usedVertices += 4;
-        prevNode.setTop(itemTop);
-    } else {
-        usedVertices += (prevNode.top() != itemTop ? 6 : 4);
-        prevNode.setTop(TimelineModel::defaultRowHeight());
+    switch (currentNode.direction()) {
+    case OpaqueColoredPoint2DWithSize::BottomToTop:
+        usedVertices += VerticesForSameHeight;
+        return VerticesForSameHeight;
+    case OpaqueColoredPoint2DWithSize::TopToBottom: {
+        VerticesPerEvent vertices = (prevNode.top() != currentNode.top() ?
+                    VerticesForDifferentHeight : VerticesForSameHeight);
+        usedVertices += vertices;
+        return vertices;
+    } default:
+        return NoVertices;
    }
 }

+void TimelineItemsGeometry::nextNode(float itemLeft, float itemTop, float itemWidth,
+                                     float selectionId, uchar red, uchar green, uchar blue)
+{
+    prevNode = currentNode;
+    currentNode.set(itemLeft, itemTop, itemWidth, TimelineModel::defaultRowHeight() - itemTop,
+                    selectionId, red, green, blue,
+                    currentNode.direction() == OpaqueColoredPoint2DWithSize::TopToBottom ?
+                        OpaqueColoredPoint2DWithSize::BottomToTop :
+                        OpaqueColoredPoint2DWithSize::TopToBottom);
+}
+
+void TimelineItemsGeometry::updateCurrentNode(float itemRight, float itemTop)
+{
+    currentNode.update(itemRight, itemTop);
+}
+
 class TimelineExpandedRowNode : public QSGNode {
 public:
    TimelineItemsMaterial material;
    virtual ~TimelineExpandedRowNode() {}
 };

-static void updateNodes(int from, int to, const TimelineModel *model,
-                        const TimelineRenderState *parentState, TimelineItemsRenderPassState *state)
+static qint64 startTime(const TimelineModel *model, const TimelineRenderState *parentState, int i)
 {
-    float defaultRowHeight = TimelineModel::defaultRowHeight();
+    return qMax(parentState->start(), model->startTime(i));
+}

-    QVector<TimelineItemsGeometry> expandedPerRow(model->expandedRowCount());
-    QVector<TimelineItemsGeometry> collapsedPerRow(model->collapsedRowCount());
-
-    for (int i = from; i < to; ++i) {
-        qint64 start = qMax(parentState->start(), model->startTime(i));
-        qint64 end = qMin(parentState->end(), model->startTime(i) + model->duration(i));
-        if (start > end)
-            continue;
-
-        float itemTop = (1.0 - model->relativeHeight(i)) * defaultRowHeight;
-        expandedPerRow[model->expandedRow(i)].addVertices(itemTop);
-        collapsedPerRow[model->collapsedRow(i)].addVertices(itemTop);
-    }
-
-    for (int i = 0; i < model->expandedRowCount(); ++i) {
-        TimelineItemsGeometry &row = expandedPerRow[i];
-        if (row.usedVertices > 0) {
-            row.allocate(&static_cast<TimelineExpandedRowNode *>(state->expandedRow(i))->material);
-            state->expandedRow(i)->appendChildNode(row.node);
-        }
-    }
-
-    for (int i = 0; i < model->collapsedRowCount(); ++i) {
-        TimelineItemsGeometry &row = collapsedPerRow[i];
-        if (row.usedVertices > 0) {
-            row.allocate(state->collapsedRowMaterial());
-            state->collapsedRow(i)->appendChildNode(row.node);
-        }
-    }
-
-    for (int i = from; i < to; ++i) {
-        qint64 start = qMax(parentState->start(), model->startTime(i));
-        qint64 end = qMin(parentState->end(), model->startTime(i) + model->duration(i));
-        if (start > end)
-            continue;
-
-        QColor color = model->color(i);
-        uchar red = color.red();
-        uchar green = color.green();
-        uchar blue = color.blue();
-
-        float itemWidth = end > start ? (end - start) * parentState->scale() :
-                                        std::numeric_limits<float>::min();
-        float itemLeft = (start - parentState->start()) * parentState->scale();
-
-        // This has to be the exact same expression as above, to guarantee determinism.
-        float itemTop = (1.0 - model->relativeHeight(i)) * defaultRowHeight;
-        float selectionId = model->selectionId(i);
-
-        expandedPerRow[model->expandedRow(i)].addEvent(itemLeft, itemTop, itemWidth, selectionId,
-                                                       red, green, blue);
-        collapsedPerRow[model->collapsedRow(i)].addEvent(itemLeft, itemTop, itemWidth, selectionId,
-                                                         red, green, blue);
-    }
+static qint64 endTime(const TimelineModel *model, const TimelineRenderState *parentState, int i)
+{
+    return qMin(parentState->end(), model->startTime(i) + model->duration(i));
 }

 const QSGGeometry::AttributeSet &OpaqueColoredPoint2DWithSize::attributes()
@@ -294,23 +399,9 @@ TimelineRenderPass::State *TimelineItemsRenderPass::update(const TimelineAbstrac

    state->updateCollapsedRowMaterial(spacing / parentState->scale(), selectedItem, selectionColor);

-    if (state->indexFrom() < state->indexTo()) {
-        if (indexFrom < state->indexFrom()) {
-            for (int i = indexFrom; i < state->indexFrom();
-                 i+= TimelineItemsGeometry::maxEventsPerNode)
-                updateNodes(i, qMin(i + TimelineItemsGeometry::maxEventsPerNode,
-                                    state->indexFrom()), model, parentState, state);
-        }
-        if (indexTo > state->indexTo()) {
-            for (int i = state->indexTo(); i < indexTo; i+= TimelineItemsGeometry::maxEventsPerNode)
-                updateNodes(i, qMin(i + TimelineItemsGeometry::maxEventsPerNode, indexTo), model,
-                            parentState, state);
-        }
-    } else {
-        for (int i = indexFrom; i < indexTo; i+= TimelineItemsGeometry::maxEventsPerNode)
-            updateNodes(i, qMin(i + TimelineItemsGeometry::maxEventsPerNode, indexTo), model,
-                        parentState, state);
-    }
+    NodeUpdater updater(model, parentState, state, indexFrom, indexTo);
+    updater.run();
+

    if (model->expanded()) {
        for (int row = 0; row < model->expandedRowCount(); ++row) {
@@ -473,4 +564,190 @@ void TimelineItemsRenderPassState::updateCollapsedRowMaterial(float xScale, int
    m_collapsedRowMaterial.setSelectionColor(selectionColor);
 }

+NodeUpdater::NodeUpdater(const TimelineModel *model, const TimelineRenderState *parentState,
+                         TimelineItemsRenderPassState *state, int indexFrom, int indexTo) :
+    m_model(model), m_parentState(parentState), m_indexFrom(indexFrom), m_indexTo(indexTo),
+    m_state(state)
+{
+    int numItems = m_indexTo - m_indexFrom;
+    if (numItems > s_maxNumItems) {
+        m_collapsedDistances.resize(numItems);
+        m_expandedDistances.resize(numItems);
+        QVarLengthArray<qint64> startsPerExpandedRow(m_model->expandedRowCount());
+        QVarLengthArray<qint64> startsPerCollapsedRow(m_model->collapsedRowCount());
+        memset(startsPerCollapsedRow.data(), 0xff, startsPerCollapsedRow.size());
+        memset(startsPerExpandedRow.data(), 0xff, startsPerExpandedRow.size());
+        for (int i = m_indexFrom; i < m_indexTo; ++i) {
+            // Add some "random" factor. Distances below 256ns cannot be properly displayed
+            // anyway and if all events have the same distance from one another, then we'd merge
+            // them all together otherwise.
+            qint64 start = startTime(m_model, m_parentState, i) + (i % 256);
+            qint64 end = endTime(m_model, m_parentState, i) + (i % 256);
+            if (start > end) {
+                m_collapsedDistances[i - m_indexFrom] = m_expandedDistances[i - m_indexFrom] = 0;
+                continue;
+            }
+
+            qint64 &collapsedStart = startsPerCollapsedRow[m_model->collapsedRow(i)];
+            m_collapsedDistances[i - m_indexFrom] = (collapsedStart != s_invalidTimestamp) ?
+                        end - collapsedStart : std::numeric_limits<qint64>::max();
+            collapsedStart = start;
+
+            qint64 &expandedStart = startsPerExpandedRow[m_model->expandedRow(i)];
+            m_expandedDistances[i - m_indexFrom] = (expandedStart != s_invalidTimestamp) ?
+                        end - expandedStart : std::numeric_limits<qint64>::max();
+            expandedStart = start;
+        }
+
+        QVarLengthArray<qint64> sorted = m_collapsedDistances;
+        std::sort(sorted.begin(), sorted.end());
+        m_minCollapsedDistance = sorted[numItems - s_maxNumItems];
+        sorted = m_expandedDistances;
+        std::sort(sorted.begin(), sorted.end());
+        m_minExpandedDistance = sorted[numItems - s_maxNumItems];
+    }
+}
+
+int NodeUpdater::updateVertices(TimelineItemsGeometry &geometry,
+                                const QVarLengthArray<qint64> &distances, qint64 minDistance,
+                                float itemTop, int i) const
+{
+    int vertices = 0;
+    if (geometry.isEmpty()) {
+        // We'll run another addVertices() on each row with content after the loop.
+        // Reserve some space for that.
+        vertices = TimelineItemsGeometry::VerticesForDifferentHeight;
+        geometry.nextNode(0, itemTop);
+    } else if (distances.isEmpty() || distances[i - m_indexFrom] > minDistance) {
+        vertices = geometry.addVertices();
+        geometry.nextNode(0, itemTop);
+    } else {
+        geometry.updateCurrentNode(0, itemTop);
+    }
+    return vertices;
+}
+
+void NodeUpdater::addEvent(TimelineItemsGeometry &geometry,
+                           const QVarLengthArray<qint64> &distances, qint64 minDistance,
+                           const NodeUpdater::ItemDescription &item, int i) const
+{
+    if (geometry.isEmpty()) {
+        geometry.nextNode(item.left, item.top, item.width, item.selectionId, item.red,
+                          item.green, item.blue);
+    } else if (distances.isEmpty() || distances[i - m_indexFrom] > minDistance) {
+        geometry.addEvent();
+        geometry.nextNode(item.left, item.top, item.width, item.selectionId, item.red,
+                          item.green, item.blue);
+    } else {
+        geometry.updateCurrentNode(item.right, item.top);
+    }
+}
+
+int NodeUpdater::updateNodes(const int from, const int to) const
+{
+    float defaultRowHeight = TimelineModel::defaultRowHeight();
+
+    QVector<TimelineItemsGeometry> expandedPerRow(m_model->expandedRowCount());
+    QVector<TimelineItemsGeometry> collapsedPerRow(m_model->collapsedRowCount());
+
+    int collapsedVertices = 0;
+    int expandedVertices = 0;
+    int lastEvent = from;
+    for (;lastEvent < to
+         && collapsedVertices < TimelineItemsGeometry::maxVerticesPerNode
+         && expandedVertices < TimelineItemsGeometry::maxVerticesPerNode;
+         ++lastEvent) {
+        qint64 start = startTime(m_model, m_parentState, lastEvent);
+        qint64 end = endTime(m_model, m_parentState, lastEvent);
+        if (start > end)
+            continue;
+
+        float itemTop = (1.0 - m_model->relativeHeight(lastEvent)) * defaultRowHeight;
+
+        expandedVertices += updateVertices(expandedPerRow[m_model->expandedRow(lastEvent)],
+                m_expandedDistances, m_minExpandedDistance, itemTop, lastEvent);
+        collapsedVertices += updateVertices(collapsedPerRow[m_model->collapsedRow(lastEvent)],
+                m_collapsedDistances, m_minCollapsedDistance, itemTop, lastEvent);
+    }
+
+    for (int i = 0, end = m_model->expandedRowCount(); i < end; ++i) {
+        TimelineItemsGeometry &row = expandedPerRow[i];
+        if (row.currentNode.direction() != OpaqueColoredPoint2DWithSize::InvalidDirection)
+            row.addVertices();
+        if (row.usedVertices > 0) {
+            row.allocate(&static_cast<TimelineExpandedRowNode *>(
+                             m_state->expandedRow(i))->material);
+            m_state->expandedRow(i)->appendChildNode(row.node);
+        }
+    }
+
+    for (int i = 0; i < m_model->collapsedRowCount(); ++i) {
+        TimelineItemsGeometry &row = collapsedPerRow[i];
+        if (row.currentNode.direction() != OpaqueColoredPoint2DWithSize::InvalidDirection)
+            row.addVertices();
+        if (row.usedVertices > 0) {
+            row.allocate(m_state->collapsedRowMaterial());
+            m_state->collapsedRow(i)->appendChildNode(row.node);
+        }
+    }
+
+    ItemDescription item;
+    for (int i = from; i < lastEvent; ++i) {
+        qint64 start = startTime(m_model, m_parentState, i);
+        qint64 end = endTime(m_model, m_parentState, i);
+        if (start > end)
+            continue;
+
+        QColor color = m_model->color(i);
+        item.red = color.red();
+        item.green = color.green();
+        item.blue = color.blue();
+
+        item.width = end > start ? (end - start) * m_parentState->scale() :
+                                   std::numeric_limits<float>::min();
+        item.left = (start - m_parentState->start()) * m_parentState->scale();
+        item.right = (end - m_parentState->start()) * m_parentState->scale();
+
+        // This has to be the exact same expression as above, to guarantee determinism.
+        item.top = (1.0 - m_model->relativeHeight(i)) * defaultRowHeight;
+        item.selectionId = m_model->selectionId(i);
+
+        addEvent(expandedPerRow[m_model->expandedRow(i)], m_expandedDistances,
+                m_minExpandedDistance, item, i);
+        addEvent(collapsedPerRow[m_model->collapsedRow(i)], m_collapsedDistances,
+                m_minCollapsedDistance, item, i);
+    }
+
+    for (int i = 0, end = m_model->expandedRowCount(); i < end; ++i) {
+        TimelineItemsGeometry &row = expandedPerRow[i];
+        if (row.currentNode.direction() != OpaqueColoredPoint2DWithSize::InvalidDirection)
+            row.addEvent();
+    }
+
+    for (int i = 0, end = m_model->collapsedRowCount(); i < end; ++i) {
+        TimelineItemsGeometry &row = collapsedPerRow[i];
+        if (row.currentNode.direction() != OpaqueColoredPoint2DWithSize::InvalidDirection)
+            row.addEvent();
+    }
+
+    return lastEvent;
+}
+
+void NodeUpdater::run()
+{
+    if (m_state->indexFrom() < m_state->indexTo()) {
+        if (m_indexFrom < m_state->indexFrom()) {
+            for (int i = m_indexFrom; i < m_state->indexFrom();)
+                i = updateNodes(i, m_state->indexFrom());
+        }
+        if (m_indexTo > m_state->indexTo()) {
+            for (int i = m_state->indexTo(); i < m_indexTo;)
+                i = updateNodes(i, m_indexTo);
+        }
+    } else {
+        for (int i = m_indexFrom; i < m_indexTo;)
+            i = updateNodes(i, m_indexTo);
+    }
+}
+
 } // namespace Timeline
--- a/src/libs/timeline/timelineitemsrenderpass.h
+++ b/src/libs/timeline/timelineitemsrenderpass.h
@@ -56,9 +56,23 @@ private:
 class OpaqueColoredPoint2DWithSize
 {
 public:
-    void set(float nx, float ny, float nw, float nh, float nid, uchar nr, uchar ng, uchar nb);
+    enum Direction {
+        InvalidDirection,
+        TopToBottom,
+        BottomToTop
+    };
+
+    void set(float nx, float ny, float nw, float nh, float nid, uchar nr, uchar ng, uchar nb,
+             uchar d);
+
    float top() const;
-    void setTop(float top);
+    void update(float nr, float ny);
+    Direction direction() const;
+
+    void setBottomLeft(const OpaqueColoredPoint2DWithSize *master);
+    void setBottomRight(const OpaqueColoredPoint2DWithSize *master);
+    void setTopLeft(const OpaqueColoredPoint2DWithSize *master);
+    void setTopRight(const OpaqueColoredPoint2DWithSize *master);

    static const QSGGeometry::AttributeSet &attributes();
    static OpaqueColoredPoint2DWithSize *fromVertexData(QSGGeometry *geometry);
@@ -66,6 +80,12 @@ public:
 private:
    float x, y, w, h, id;
    unsigned char r, g, b, a;
+
+    void setCommon(const OpaqueColoredPoint2DWithSize *master);
+    void setLeft(const OpaqueColoredPoint2DWithSize *master);
+    void setRight(const OpaqueColoredPoint2DWithSize *master);
+    void setTop(const OpaqueColoredPoint2DWithSize *master);
+    void setBottom(const OpaqueColoredPoint2DWithSize *master);
 };

 class TIMELINE_EXPORT TimelineItemsRenderPass : public TimelineRenderPass
--- a/src/libs/timeline/timelineselectionrenderpass.cpp
+++ b/src/libs/timeline/timelineselectionrenderpass.cpp
@@ -39,7 +39,7 @@ QSGGeometryNode *createSelectionNode(QSGMaterial *material)
    geometry->setDrawingMode(GL_TRIANGLE_STRIP);
    OpaqueColoredPoint2DWithSize *v = OpaqueColoredPoint2DWithSize::fromVertexData(geometry);
    for (int i = 0; i < 4; ++i)
-        v[i].set(0, 0, 0, 0, 0, 0, 0, 0);
+        v[i].set(0, 0, 0, 0, 0, 0, 0, 0, 0);
    selectionNode->setGeometry(geometry);
    selectionNode->setFlag(QSGNode::OwnsGeometry, true);
    selectionNode->setFlag(QSGNode::OwnedByParent, false);
@@ -119,13 +119,13 @@ TimelineRenderPass::State *TimelineSelectionRenderPass::update(
        OpaqueColoredPoint2DWithSize *v = OpaqueColoredPoint2DWithSize::fromVertexData(
                    node->geometry());
        v[0].set(position.left(), position.bottom(), -position.width(), -position.height(),
-                 selectionId, red, green, blue);
+                 selectionId, red, green, blue, 255);
        v[1].set(position.right(), position.bottom(), position.width(), -position.height(),
-                 selectionId, red, green, blue);
+                 selectionId, red, green, blue, 255);
        v[2].set(position.left(), position.top(), -position.width(), position.height(),
-                 selectionId, red, green, blue);
+                 selectionId, red, green, blue, 255);
        v[3].set(position.right(), position.top(), position.width(), position.height(),
-                 selectionId, red, green, blue);
+                 selectionId, red, green, blue, 255);
        state->material()->setSelectionColor(renderer->selectionLocked() ? QColor(96,0,255) :
                                                                           Qt::blue);
        state->material()->setSelectedItem(selectionId);
@@ -135,7 +135,7 @@ TimelineRenderPass::State *TimelineSelectionRenderPass::update(
        OpaqueColoredPoint2DWithSize *v = OpaqueColoredPoint2DWithSize::fromVertexData(
                    node->geometry());
        for (int i = 0; i < 4; ++i)
-            v[i].set(0, 0, 0, 0, 0, 0, 0, 0);
+            v[i].set(0, 0, 0, 0, 0, 0, 0, 0, 0);
        node->markDirty(QSGNode::DirtyGeometry);
    }
    return state;