KoShapeReorderCommand Class Reference

This command allows you to change the zIndex of a number of shapes. More...

#include <KoShapeReorderCommand.h>

Inheritance diagram for KoShapeReorderCommand:

Classes
struct	IndexedShape

Public Types
enum	MoveShapeType { RaiseShape , LowerShape , BringToFront , SendToBack }
	An enum for defining what kind of reordering to use. More...

Public Member Functions
	KoShapeReorderCommand (const QList< IndexedShape > &shapes, KUndo2Command *parent=0)
	KoShapeReorderCommand (const QList< KoShape * > &shapes, QList< int > &newIndexes, KUndo2Command *parent=0)
void	redo () override
	redo the command
void	undo () override
	revert the actions done in redo
	~KoShapeReorderCommand () override
Public Member Functions inherited from KUndo2Command
QString	actionText () const
virtual bool	canAnnihilateWith (const KUndo2Command *other) const
const KUndo2Command *	child (int index) const
int	childCount () const
virtual QTime	endTime () const
KUndo2CommandExtraData *	extraData () const
bool	hasParent () const
virtual int	id () const
virtual bool	isMerged () const
	KUndo2Command (const KUndo2MagicString &text, KUndo2Command *parent=0)
	KUndo2Command (KUndo2Command *parent=0)
virtual QVector< KUndo2Command * >	mergeCommandsVector () const
virtual bool	mergeWith (const KUndo2Command *other)
virtual void	redoMergedCommands ()
void	setEndTime ()
virtual void	setEndTime (const QTime &time)
void	setExtraData (KUndo2CommandExtraData *data)
void	setText (const KUndo2MagicString &text)
void	setTime ()
virtual void	setTime (const QTime &time)
virtual void	setTimedID (int timedID)
KUndo2MagicString	text () const
virtual QTime	time () const
virtual int	timedId () const
virtual bool	timedMergeWith (KUndo2Command *other)
virtual void	undoMergedCommands ()
virtual	~KUndo2Command ()

Static Public Member Functions
static KoShapeReorderCommand *	createCommand (const QList< KoShape * > &shapes, KoShapeManager *manager, MoveShapeType move, KUndo2Command *parent=0)
static QList< KoShapeReorderCommand::IndexedShape >	homogenizeZIndexes (QList< IndexedShape > shapes)
static QList< KoShapeReorderCommand::IndexedShape >	homogenizeZIndexesLazy (QList< IndexedShape > shapes)
static QList< IndexedShape >	mergeDownShapes (QList< KoShape * > shapesBelow, QList< KoShape * > shapesAbove)
static KoShapeReorderCommand *	mergeInShape (QList< KoShape * > shapes, KoShape *newShape, KUndo2Command *parent=0)
	mergeInShape adjust zIndex of all the shapes and newShape to avoid collisions between shapes and newShape.

Private Attributes
KoShapeReorderCommandPrivate *const	d

Detailed Description

This command allows you to change the zIndex of a number of shapes.

Definition at line 21 of file KoShapeReorderCommand.h.

Member Enumeration Documentation

MoveShapeType

enum KoShapeReorderCommand::MoveShapeType

An enum for defining what kind of reordering to use.

Enumerator
RaiseShape	raise the selected shape to the level that it is above the shape that is on top of it.
LowerShape	Lower the selected shape to the level that it is below the shape that is below it.
BringToFront	Raise the selected shape to be on top of all shapes.
SendToBack	Lower the selected shape to be below all other shapes.

Definition at line 48 of file KoShapeReorderCommand.h.

                        {
        RaiseShape,     
        LowerShape,     
        BringToFront,   
        SendToBack      
    };

Constructor & Destructor Documentation

KoShapeReorderCommand() [1/2]

KoShapeReorderCommand::KoShapeReorderCommand	(	const QList< KoShape * > &	shapes,
		QList< int > &	newIndexes,
		KUndo2Command *	parent = 0 )

Constructor.

Parameters

shapes	the set of objects that are moved.
newIndexes	the new indexes for the shapes. this list naturally must have the same amount of items as the shapes set.
parent	the parent command used for macro commands

Definition at line 45 of file KoShapeReorderCommand.cpp.

    : KUndo2Command(parent),
      d(new KoShapeReorderCommandPrivate(shapes, newIndexes))
{
    Q_ASSERT(shapes.count() == newIndexes.count());
    foreach (KoShape *shape, shapes)
        d->previousIndexes.append(shape->zIndex());
 
    setText(kundo2_i18n("Reorder shapes"));
}

References d, kundo2_i18n(), KoShapeReorderCommandPrivate::previousIndexes, KUndo2Command::setText(), and KoShape::zIndex().

KoShapeReorderCommand() [2/2]

KoShapeReorderCommand::KoShapeReorderCommand	(	const QList< IndexedShape > &	shapes,
		KUndo2Command *	parent = 0 )

Definition at line 56 of file KoShapeReorderCommand.cpp.

    : KUndo2Command(parent),
      d(new KoShapeReorderCommandPrivate())
{
    Q_FOREACH (const IndexedShape &index, shapes) {
        d->shapes.append(index.shape);
        d->newIndexes.append(index.zIndex);
        d->previousIndexes.append(index.shape->zIndex());
    }
 
    setText(kundo2_i18n("Reorder shapes"));
}

References d, kundo2_i18n(), KoShapeReorderCommandPrivate::newIndexes, KoShapeReorderCommandPrivate::previousIndexes, KUndo2Command::setText(), KoShapeReorderCommand::IndexedShape::shape, KoShapeReorderCommandPrivate::shapes, KoShapeReorderCommand::IndexedShape::zIndex, and KoShape::zIndex().

~KoShapeReorderCommand()

KoShapeReorderCommand::~KoShapeReorderCommand ( )

override

Definition at line 69 of file KoShapeReorderCommand.cpp.

{
    delete d;
}

References d.

Member Function Documentation

createCommand()

KoShapeReorderCommand * KoShapeReorderCommand::createCommand ( const QList< KoShape * > & shapes, KoShapeManager * manager, MoveShapeType move, KUndo2Command * parent = 0 )

static

Create a new KoShapeReorderCommand by calculating the new indexes required to move the shapes according to the move parameter.

Parameters

shapes	all the shapes that should be moved.
manager	the shapeManager that contains all the shapes that could have their indexes changed.
move	the moving type.
parent	the parent command for grouping purposes.

Returns

command for reordering the shapes or 0 if no reordering happened

TODO: this method doesn't handle the case when one of the shapes has maximum or minimum zIndex value (which is 16-bit in our case)!

Definition at line 142 of file KoShapeReorderCommand.cpp.

{
    QList<int> newIndexes;
    QList<KoShape*> changedShapes;
    QMap<KoShape*, QList<KoShape*> > newOrder;
    QList<KoShape*> sortedShapes(shapes);
    std::sort(sortedShapes.begin(), sortedShapes.end(), KoShape::compareShapeZIndex);
    if (move == BringToFront || move == LowerShape) {
        for (int i = 0; i < sortedShapes.size(); ++i) {
            prepare(sortedShapes.at(i), newOrder, manager, move);
        }
    }
    else {
        for (int i = sortedShapes.size() - 1; i >= 0; --i) {
            prepare(sortedShapes.at(i), newOrder, manager, move);
        }
    }
 
    QMap<KoShape*, QList<KoShape*> >::iterator newIt(newOrder.begin());
    for (; newIt != newOrder.end(); ++newIt) {
        QList<KoShape*> order(newIt.value());
        order.removeAll(nullptr);
        int index = -KoShape::maxZIndex - 1; // set minimum zIndex
        int pos = 0;
        for (; pos < order.size(); ++pos) {
            if (order[pos]->zIndex() > index) {
                index = order[pos]->zIndex();
            }
            else {
                break;
            }
        }
 
        if (pos == order.size()) {
            //nothing needs to be done
            continue;
        }
        else if (pos <= order.size() / 2) {
            // new index for the front
            int startIndex = order[pos]->zIndex() - pos;
            for (int i = 0; i < pos; ++i) {
                changedShapes.append(order[i]);
                newIndexes.append(startIndex++);
            }
        }
        else {
            //new index for the end
            for (int i = pos; i < order.size(); ++i) {
                changedShapes.append(order[i]);
                newIndexes.append(++index);
            }
        }
    }
    Q_ASSERT(changedShapes.count() == newIndexes.count());
    return changedShapes.isEmpty() ? 0: new KoShapeReorderCommand(changedShapes, newIndexes, parent);
}

References BringToFront, KoShape::compareShapeZIndex(), KoShapeReorderCommand(), LowerShape, KoShape::maxZIndex, and prepare().

homogenizeZIndexes()

QList< KoShapeReorderCommand::IndexedShape > KoShapeReorderCommand::homogenizeZIndexes ( QList< IndexedShape > shapes )

static

Recalculates the attached z-indexes of shapes so that all indexes go strictly in ascending order and no shapes have repetitive indexes. The physical order of the shapes in the array is not changed, on the indexes in IndexedShape are corrected.

Definition at line 243 of file KoShapeReorderCommand.cpp.

{
    if (shapes.isEmpty()) return shapes;
 
    // the shapes are expected to be sorted, we just need to adjust the indexes
 
    int lastIndex = shapes.begin()->zIndex;
 
    auto it = shapes.begin() + 1;
    while (it != shapes.end()) {
        if (it->zIndex <= lastIndex) {
            it->zIndex = lastIndex + 1;
        }
        lastIndex = it->zIndex;
        ++it;
    }
 
    const int overflowSize = shapes.last().zIndex - int(std::numeric_limits<qint16>::max());
 
    if (overflowSize > 0) {
        if (shapes.first().zIndex - overflowSize > int(std::numeric_limits<qint16>::min())) {
            for (auto it = shapes.begin(); it != shapes.end(); ++it) {
                it->zIndex -= overflowSize;
            }
        } else {
            int index = shapes.size() < int(std::numeric_limits<qint16>::max()) ?
                        0 :
                        int(std::numeric_limits<qint16>::max()) - shapes.size();
 
            for (auto it = shapes.begin(); it != shapes.end(); ++it) {
                it->zIndex = index;
                index++;
            }
        }
    }
 
    return shapes;
}

homogenizeZIndexesLazy()

QList< KoShapeReorderCommand::IndexedShape > KoShapeReorderCommand::homogenizeZIndexesLazy ( QList< IndexedShape > shapes )

static

Convenience version of homogenizeZIndexes() that removes all the IndexedShape objects, which z-index didn't change during homogenization. In a result you get a list that can be passed to KoShapeReorderCommand directly.

Definition at line 283 of file KoShapeReorderCommand.cpp.

{
    shapes = homogenizeZIndexes(shapes);
    // remove shapes that didn't change
    for (auto it = shapes.begin(); it != shapes.end();) {
        if (it->zIndex == it->shape->zIndex()) {
            it = shapes.erase(it);
        } else {
            ++it;
        }
    }
 
    return shapes;
}

References homogenizeZIndexes().

mergeDownShapes()

QList< KoShapeReorderCommand::IndexedShape > KoShapeReorderCommand::mergeDownShapes ( QList< KoShape * > shapesBelow, QList< KoShape * > shapesAbove )

static

Put all the shapes in shapesAbove above the shapes in shapesBelow, adjusting their z-index values.

Definition at line 299 of file KoShapeReorderCommand.cpp.

{
    std::sort(shapesBelow.begin(), shapesBelow.end(), KoShape::compareShapeZIndex);
    std::sort(shapesAbove.begin(), shapesAbove.end(), KoShape::compareShapeZIndex);
 
    QList<IndexedShape> shapes;
    Q_FOREACH (KoShape *shape, shapesBelow) {
        shapes.append(IndexedShape(shape));
    }
 
    Q_FOREACH (KoShape *shape, shapesAbove) {
        shapes.append(IndexedShape(shape));
    }
 
    return homogenizeZIndexesLazy(shapes);
}

References KoShape::compareShapeZIndex(), and homogenizeZIndexesLazy().

mergeInShape()

KoShapeReorderCommand * KoShapeReorderCommand::mergeInShape ( QList< KoShape * > shapes, KoShape * newShape, KUndo2Command * parent = 0 )

static

mergeInShape adjust zIndex of all the shapes and newShape to avoid collisions between shapes and newShape.

Note1: newShape may or may not be contained in shapes, there is no difference. Note2: the collisions inside shapes are ignored. They are just adjusted to avoid collisions with newShape only

Parameters

shapes	list of shapes
newShape	the new shape
parent	the parent command for grouping purposes.

Returns

command for reordering the shapes or 0 if no reordering happened

Definition at line 204 of file KoShapeReorderCommand.cpp.

{
    std::sort(shapes.begin(), shapes.end(), KoShape::compareShapeZIndex);
 
    QList<KoShape*> reindexedShapes;
    QList<int> reindexedIndexes;
 
    const int originalShapeZIndex = newShape->zIndex();
    int newShapeZIndex = originalShapeZIndex;
    int lastOccupiedShapeZIndex = originalShapeZIndex + 1;
 
    Q_FOREACH (KoShape *shape, shapes) {
        if (shape == newShape) continue;
 
        const int zIndex = shape->zIndex();
 
        if (newShapeZIndex == originalShapeZIndex) {
            if (zIndex == originalShapeZIndex) {
                newShapeZIndex = originalShapeZIndex + 1;
                lastOccupiedShapeZIndex = newShapeZIndex;
 
                reindexedShapes << newShape;
                reindexedIndexes << newShapeZIndex;
            }
        } else {
            if (zIndex >= newShapeZIndex &&
                zIndex <= lastOccupiedShapeZIndex) {
 
                lastOccupiedShapeZIndex = zIndex + 1;
                reindexedShapes << shape;
                reindexedIndexes << lastOccupiedShapeZIndex;
            }
        }
    }
 
    return !reindexedShapes.isEmpty() ? new KoShapeReorderCommand(reindexedShapes, reindexedIndexes, parent) : 0;
}

References KoShape::compareShapeZIndex(), KoShapeReorderCommand(), and KoShape::zIndex().

redo()

void KoShapeReorderCommand::redo ( )

overridevirtual

redo the command

Reimplemented from KUndo2Command.

Definition at line 74 of file KoShapeReorderCommand.cpp.

{
    KUndo2Command::redo();
    for (int i = 0; i < d->shapes.count(); i++) {
        // z-index cannot change the bounding rect of the shape, so
        // no united updates needed
        d->shapes.at(i)->setZIndex(d->newIndexes.at(i));
        d->shapes.at(i)->update();
    }
}

References d, KoShapeReorderCommandPrivate::newIndexes, KUndo2Command::redo(), and KoShapeReorderCommandPrivate::shapes.

undo()

void KoShapeReorderCommand::undo ( )

overridevirtual

revert the actions done in redo

Reimplemented from KUndo2Command.

Definition at line 85 of file KoShapeReorderCommand.cpp.

{
    KUndo2Command::undo();
    for (int i = 0; i < d->shapes.count(); i++) {
        // z-index cannot change the bounding rect of the shape, so
        // no united updates needed
        d->shapes.at(i)->setZIndex(d->previousIndexes.at(i));
        d->shapes.at(i)->update();
    }
}

References d, KoShapeReorderCommandPrivate::previousIndexes, KoShapeReorderCommandPrivate::shapes, and KUndo2Command::undo().

Member Data Documentation

d

KoShapeReorderCommandPrivate* const KoShapeReorderCommand::d

private

Definition at line 114 of file KoShapeReorderCommand.h.

---

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

• libs/flake/commands/KoShapeReorderCommand.h
• libs/flake/commands/KoShapeReorderCommand.cpp