QSpanCollection Class Reference

#include <qtableview_p.h>

Classes
struct	Span

Public Types
typedef QLinkedList< Span * >	SpanList

Public Functions
void	addSpan (Span *span)
void	clear ()
Span *	spanAt (int x, int y) const
QList< Span * >	spansInRect (int x, int y, int w, int h) const
void	updateInsertedColumns (int start, int end)
void	updateInsertedRows (int start, int end)
void	updateRemovedColumns (int start, int end)
void	updateRemovedRows (int start, int end)
void	updateSpan (Span *span, int old_height)
	~QSpanCollection ()

Public Variables
SpanList	spans

Private Types
typedef QMap< int, SubIndex >	Index
typedef QMap< int, Span * >	SubIndex

Private Functions
bool	cleanSpanSubIndex (SubIndex &subindex, int end, bool update=false)

Properties
Index	index

Detailed Description

Warning

This function is not part of the public interface.

This is a list of span with a binary index to look up quickly a span at a certain index.

The index is a map of map. spans are mentaly divided into sub spans so that the start of any subspans doesn't overlap with any other subspans. There is no real representation of the subspans. The key of the first map is the row where the subspan starts, the value of the first map is a list (map) of all subspans that starts at the same row. It is indexed with its row

Definition at line 77 of file qtableview_p.h.

Typedefs

Index

typedef QMap<int, SubIndex> QSpanCollection::Index

private

Definition at line 124 of file qtableview_p.h.

SpanList

typedef QLinkedList<Span *> QSpanCollection::SpanList

Definition at line 119 of file qtableview_p.h.

SubIndex

typedef QMap<int, Span *> QSpanCollection::SubIndex

private

Definition at line 123 of file qtableview_p.h.

Constructors and Destructors

~QSpanCollection()

QSpanCollection::~QSpanCollection ( )

inline

Definition at line 99 of file qtableview_p.h.

    {
        qDeleteAll(spans);
    }

Functions

addSpan()

void QSpanCollection::addSpan

(

QSpanCollection::Span *

span

)

Warning

This function is not part of the public interface. Add a span to the collection. the collection takes the ownership.

Definition at line 65 of file qtableview.cpp.

{
    spans.append(span);
    Index::iterator it_y = index.lowerBound(-span->top());
    if (it_y == index.end() || it_y.key() != -span->top()) {
        //there is no spans that starts with the row in the index, so create a sublist for it.
        SubIndex sub_index;
        if (it_y != index.end()) {
            //the previouslist is the list of spans that sarts _before_ the row of the span.
            // and which may intersect this row.
            const SubIndex previousList = it_y.value();
            foreach(Span *s, previousList) {
                //If a subspans intersect the row, we need to split it into subspans
                if(s->bottom() >= span->top())
                    sub_index.insert(-s->left(), s);
            }
        }
        it_y = index.insert(-span->top(), sub_index);
        //we will insert span to *it_y in the later loop
    }

    //insert the span as supspan in all the lists that intesects the span
    while(-it_y.key() <= span->bottom()) {
        (*it_y).insert(-span->left(), span);
        if(it_y == index.begin())
            break;
        --it_y;
    }
}

cleanSpanSubIndex()

bool QSpanCollection::cleanSpanSubIndex ( QSpanCollection::SubIndex &  subindex, int  y, bool  update = false  )

private

Warning

This function is not part of the public interface. Cleans a subindex from to be deleted spans. The update argument is used to move the spans inside the subindex, in case their anchor changed.

Returns

true if no span in this subindex starts at y, and should thus be deleted.

Definition at line 312 of file qtableview.cpp.

Referenced by updateRemovedColumns(), and updateRemovedRows().

{
    if (subindex.isEmpty())
        return true;

    bool should_be_deleted = true;
    SubIndex::iterator it = subindex.end();
    do {
        --it;
        int x = -it.key();
        Span *span = it.value();
        if (span->will_be_deleted) {
            it = subindex.erase(it);
            continue;
        }
        if (update && span->m_left != x) {
            subindex.insert(-span->m_left, span);
            it = subindex.erase(it);
        }
        if (should_be_deleted && span->m_top == y)
            should_be_deleted = false;
    } while (it != subindex.begin());

    return should_be_deleted;
}

clear()

void QSpanCollection::clear

(

)

Warning

This function is not part of the public interface. remove and deletes all spans inside the collection

Definition at line 160 of file qtableview.cpp.

{
    qDeleteAll(spans);
    index.clear();
    spans.clear();
}

spanAt()

QSpanCollection::Span * QSpanCollection::spanAt	(	int	x,
		int	y
	)		const

Warning

This function is not part of the public interface.

Returns

a spans that spans over cell x,y (column,row) or 0 if there is none.

Definition at line 142 of file qtableview.cpp.

{
    Index::const_iterator it_y = index.lowerBound(-y);
    if (it_y == index.end())
        return 0;
    SubIndex::const_iterator it_x = (*it_y).lowerBound(-x);
    if (it_x == (*it_y).end())
        return 0;
    Span *span = *it_x;
    if (span->right() >= x && span->bottom() >= y)
        return span;
    return 0;
}

spansInRect()

QList< QSpanCollection::Span * > QSpanCollection::spansInRect	(	int	x,
		int	y,
		int	w,
		int	h
	)		const

Warning

This function is not part of the public interface. return a list to all the spans that spans over cells in the given rectangle

Definition at line 170 of file qtableview.cpp.

{
    QSet<Span *> list;
    Index::const_iterator it_y = index.lowerBound(-y);
    if(it_y == index.end())
        --it_y;
    while(-it_y.key() <= y + h) {
        SubIndex::const_iterator it_x = (*it_y).lowerBound(-x);
        if (it_x == (*it_y).end())
            --it_x;
        while(-it_x.key() <= x + w) {
            Span *s = *it_x;
            if (s->bottom() >= y && s->right() >= x)
                list << s;
            if (it_x == (*it_y).begin())
                break;
            --it_x;
        }
        if(it_y == index.begin())
            break;
        --it_y;
    }
    return list.toList();
}

updateInsertedColumns()

void QSpanCollection::updateInsertedColumns	(	int	start,
		int	end
	)

Warning

This function is not part of the public interface. Updates the span collection after column insertion.

Definition at line 258 of file qtableview.cpp.

{
#ifdef DEBUG_SPAN_UPDATE
    qDebug() << Q_FUNC_INFO;
    qDebug() << start << end;
    qDebug() << index;
#endif
    if (spans.isEmpty())
        return;

    int delta = end - start + 1;
#ifdef DEBUG_SPAN_UPDATE
    qDebug("Before");
#endif
    for (SpanList::iterator it = spans.begin(); it != spans.end(); ++it) {
        Span *span = *it;
#ifdef DEBUG_SPAN_UPDATE
        qDebug() << span << *span;
#endif
        if (span->m_right < start)
            continue;
        if (span->m_left >= start)
            span->m_left += delta;
        span->m_right += delta;
    }

#ifdef DEBUG_SPAN_UPDATE
    qDebug("After");
    foreach (QSpanCollection::Span *span, spans)
        qDebug() << span << *span;
#endif

    for (Index::iterator it_y = index.begin(); it_y != index.end(); ++it_y) {
        SubIndex &subindex = it_y.value();
        for (SubIndex::iterator it = subindex.begin(); it != subindex.end(); ) {
            int x = -it.key();
            if (x < start) {
                ++it;
                continue;
            }
            subindex.insert(-x - delta, it.value());
            it = subindex.erase(it);
        }
    }
#ifdef DEBUG_SPAN_UPDATE
    qDebug() << index;
#endif
}

updateInsertedRows()

void QSpanCollection::updateInsertedRows	(	int	start,
		int	end
	)

Warning

This function is not part of the public interface. Updates the span collection after row insertion.

Definition at line 208 of file qtableview.cpp.

{
#ifdef DEBUG_SPAN_UPDATE
    qDebug() << Q_FUNC_INFO;
    qDebug() << start << end;
    qDebug() << index;
#endif
    if (spans.isEmpty())
        return;

    int delta = end - start + 1;
#ifdef DEBUG_SPAN_UPDATE
    qDebug("Before");
#endif
    for (SpanList::iterator it = spans.begin(); it != spans.end(); ++it) {
        Span *span = *it;
#ifdef DEBUG_SPAN_UPDATE
        qDebug() << span << *span;
#endif
        if (span->m_bottom < start)
            continue;
        if (span->m_top >= start)
            span->m_top += delta;
        span->m_bottom += delta;
    }

#ifdef DEBUG_SPAN_UPDATE
    qDebug("After");
    foreach (QSpanCollection::Span *span, spans)
        qDebug() << span << *span;
#endif

    for (Index::iterator it_y = index.begin(); it_y != index.end(); ) {
        int y = -it_y.key();
        if (y < start) {
            ++it_y;
            continue;
        }

        index.insert(-y - delta, it_y.value());
        it_y = index.erase(it_y);
    }
#ifdef DEBUG_SPAN_UPDATE
    qDebug() << index;
#endif
}

updateRemovedColumns()

void QSpanCollection::updateRemovedColumns	(	int	start,
		int	end
	)

Warning

This function is not part of the public interface. Updates the span collection after column removal.

Definition at line 470 of file qtableview.cpp.

{
#ifdef DEBUG_SPAN_UPDATE
    qDebug() << Q_FUNC_INFO;
    qDebug() << start << end;
    qDebug() << index;
#endif
    if (spans.isEmpty())
        return;

    SpanList toBeDeleted;
    int delta = end - start + 1;
#ifdef DEBUG_SPAN_UPDATE
    qDebug("Before");
#endif
    for (SpanList::iterator it = spans.begin(); it != spans.end(); ) {
        Span *span = *it;
#ifdef DEBUG_SPAN_UPDATE
        qDebug() << span << *span;
#endif
        if (span->m_right < start) {
            ++it;
            continue;
        }
        if (span->m_left < start) {
            if (span->m_right <= end)
                span->m_right = start - 1;
            else
                span->m_right -= delta;
        } else {
            if (span->m_right > end) {
                if (span->m_left <= end)
                    span->m_left = start;
                else
                    span->m_left -= delta;
                span->m_right -= delta;
            } else {
                span->will_be_deleted = true;
            }
        }
        if (span->m_top == span->m_bottom && span->m_left == span->m_right)
            span->will_be_deleted = true;
        if (span->will_be_deleted) {
            toBeDeleted.append(span);
            it = spans.erase(it);
        } else {
            ++it;
        }
    }

#ifdef DEBUG_SPAN_UPDATE
    qDebug("After");
    foreach (QSpanCollection::Span *span, spans)
        qDebug() << span << *span;
#endif
    if (spans.isEmpty()) {
        qDeleteAll(toBeDeleted);
        index.clear();
        return;
    }

    for (Index::iterator it_y = index.begin(); it_y != index.end(); ) {
        int y = -it_y.key();
        if (cleanSpanSubIndex(it_y.value(), y, true))
            it_y = index.erase(it_y);
        else
            ++it_y;
    }

#ifdef DEBUG_SPAN_UPDATE
    qDebug() << index;
    qDebug("Deleted");
    foreach (QSpanCollection::Span *span, toBeDeleted)
        qDebug() << span << *span;
#endif
    qDeleteAll(toBeDeleted);
}

updateRemovedRows()

void QSpanCollection::updateRemovedRows	(	int	start,
		int	end
	)

Warning

This function is not part of the public interface. Updates the span collection after row removal.

Definition at line 341 of file qtableview.cpp.

{
#ifdef DEBUG_SPAN_UPDATE
    qDebug() << Q_FUNC_INFO;
    qDebug() << start << end;
    qDebug() << index;
#endif
    if (spans.isEmpty())
        return;

    SpanList spansToBeDeleted;
    int delta = end - start + 1;
#ifdef DEBUG_SPAN_UPDATE
    qDebug("Before");
#endif
    for (SpanList::iterator it = spans.begin(); it != spans.end(); ) {
        Span *span = *it;
#ifdef DEBUG_SPAN_UPDATE
        qDebug() << span << *span;
#endif
        if (span->m_bottom < start) {
            ++it;
            continue;
        }
        if (span->m_top < start) {
            if (span->m_bottom <= end)
                span->m_bottom = start - 1;
            else
                span->m_bottom -= delta;
        } else {
            if (span->m_bottom > end) {
                if (span->m_top <= end)
                    span->m_top = start;
                else
                    span->m_top -= delta;
                span->m_bottom -= delta;
            } else {
                span->will_be_deleted = true;
            }
        }
        if (span->m_top == span->m_bottom && span->m_left == span->m_right)
            span->will_be_deleted = true;
        if (span->will_be_deleted) {
            spansToBeDeleted.append(span);
            it = spans.erase(it);
        } else {
            ++it;
        }
    }

#ifdef DEBUG_SPAN_UPDATE
    qDebug("After");
    foreach (QSpanCollection::Span *span, spans)
        qDebug() << span << *span;
#endif
    if (spans.isEmpty()) {
        qDeleteAll(spansToBeDeleted);
        index.clear();
        return;
    }

    Index::iterator it_y = index.end();
    do {
        --it_y;
        int y = -it_y.key();
        SubIndex &subindex = it_y.value();
        if (y < start) {
            if (cleanSpanSubIndex(subindex, y))
                it_y = index.erase(it_y);
        } else if (y >= start && y <= end) {
            bool span_at_start = false;
            SubIndex spansToBeMoved;
            for (SubIndex::iterator it = subindex.begin(); it != subindex.end(); ++it) {
                Span *span = it.value();
                if (span->will_be_deleted)
                    continue;
                if (!span_at_start && span->m_top == start)
                    span_at_start = true;
                spansToBeMoved.insert(it.key(), span);
            }

            if (y == start && span_at_start)
                subindex.clear();
            else
                it_y = index.erase(it_y);

            if (span_at_start) {
                Index::iterator it_start;
                if (y == start)
                    it_start = it_y;
                else {
                    it_start = index.find(-start);
                    if (it_start == index.end())
                        it_start = index.insert(-start, SubIndex());
                }
                SubIndex &start_subindex = it_start.value();
                for (SubIndex::iterator it = spansToBeMoved.begin(); it != spansToBeMoved.end(); ++it)
                    start_subindex.insert(it.key(), it.value());
            }
        } else {
            if (y == end + 1) {
                Index::iterator it_top = index.find(-y + delta);
                if (it_top == index.end())
                    it_top = index.insert(-y + delta, SubIndex());
                for (SubIndex::iterator it = subindex.begin(); it != subindex.end(); ) {
                    Span *span = it.value();
                    if (!span->will_be_deleted)
                        it_top.value().insert(it.key(), span);
                    ++it;
                }
            } else {
                index.insert(-y + delta, subindex);
            }
            it_y = index.erase(it_y);
        }
    } while (it_y != index.begin());

#ifdef DEBUG_SPAN_UPDATE
    qDebug() << index;
    qDebug("Deleted");
    foreach (QSpanCollection::Span *span, spansToBeDeleted)
        qDebug() << span << *span;
#endif
    qDeleteAll(spansToBeDeleted);
}

updateSpan()

void QSpanCollection::updateSpan	(	QSpanCollection::Span *	span,
		int	old_height
	)

Warning

This function is not part of the public interface. Has to be called after the height and width of a span is changed.

old_height is the height before the change

if the size of the span is now 0x0 the span will be deleted.

Definition at line 103 of file qtableview.cpp.

{
    if (old_height < span->height()) {
        //add the span as subspan in all the lists that intersect the new covered columns
        Index::iterator it_y = index.lowerBound(-(span->top() + old_height - 1));
        Q_ASSERT(it_y != index.end()); //it_y must exist since the span is in the list
        while (-it_y.key() <= span->bottom()) {
            (*it_y).insert(-span->left(), span);
            if(it_y == index.begin())
                break;
            --it_y;
        }
    } else if (old_height > span->height()) {
        //remove the span from all the subspans lists that intersect the columns not covered anymore
        Index::iterator it_y = index.lowerBound(-qMax(span->bottom(), span->top())); //qMax useful if height is 0
        Q_ASSERT(it_y != index.end()); //it_y must exist since the span is in the list
        while (-it_y.key() <= span->top() + old_height -1) {
            if (-it_y.key() > span->bottom()) {
                int removed = (*it_y).remove(-span->left());
                Q_ASSERT(removed == 1); Q_UNUSED(removed);
                if (it_y->isEmpty()) {
                    it_y = index.erase(it_y);
                }
            }
            if(it_y == index.begin())
                break;
            --it_y;
        }
    }

    if (span->width() == 0 && span->height() == 0) {
        spans.removeOne(span);
        delete span;
    }
}

Properties

index

Index QSpanCollection::index

private

Definition at line 125 of file qtableview_p.h.

Referenced by addSpan(), clear(), QTableViewPrivate::drawAndClipSpans(), spanAt(), spansInRect(), updateInsertedColumns(), updateInsertedRows(), updateRemovedColumns(), updateRemovedRows(), and updateSpan().

spans

SpanList QSpanCollection::spans

Definition at line 120 of file qtableview_p.h.

Referenced by QTableViewPrivate::_q_updateSpanInsertedColumns(), QTableViewPrivate::_q_updateSpanInsertedRows(), QTableViewPrivate::_q_updateSpanRemovedColumns(), QTableViewPrivate::_q_updateSpanRemovedRows(), addSpan(), clear(), QTableViewPrivate::drawAndClipSpans(), QTableViewPrivate::hasSpans(), QTableViewPrivate::setSpan(), QTableViewPrivate::span(), updateInsertedColumns(), updateInsertedRows(), updateRemovedColumns(), updateRemovedRows(), and updateSpan().

---

The documentation for this class was generated from the following files:

• /src/gui/itemviews/qtableview_p.h
• /src/gui/itemviews/qtableview.cpp