void KoPathBreakAtPointCommand::undo()
{
KUndo2Command::undo();
KoPathShape * lastPathShape = 0;
for (int i = 0; i < m_pointDataList.size(); ++i) {
const KoPathPointData & pd = m_pointDataList.at(i);
KoPathShape * pathShape = pd.pathShape;
KoPathPointIndex pointIndex = pd.pointIndex;
++pointIndex.second;
if (m_closedIndex.at(i).first != -1) {
m_closedIndex[i] = pathShape->closeSubpath(m_closedIndex.at(i));
} else {
pointIndex.second = pointIndex.second + m_closedIndex.at(i).second;
pathShape->join(pd.pointIndex.first);
}
m_points[i] = pathShape->removePoint(pointIndex);
if (lastPathShape != pathShape) {
if (lastPathShape) {
lastPathShape->update();
}
lastPathShape = pathShape;
}
}
if (lastPathShape) {
lastPathShape->update();
}
m_deletePoints = true;
}
void KoPathSegmentTypeCommand::redo()
{
KUndo2Command::redo();
QList<KoPathPointData>::const_iterator it(m_pointDataList.constBegin());
for (; it != m_pointDataList.constEnd(); ++it) {
KoPathShape * pathShape = it->pathShape;
pathShape->update();
KoPathSegment segment = pathShape->segmentByIndex(it->pointIndex);
if (m_segmentType == Curve) {
// we change type to curve -> set control point positions
QPointF pointDiff = segment.second()->point() - segment.first()->point();
segment.first()->setControlPoint2(segment.first()->point() + pointDiff / 3.0);
segment.second()->setControlPoint1(segment.first()->point() + pointDiff * 2.0 / 3.0);
} else {
// we are changing type to line -> remove control points
segment.first()->removeControlPoint2();
segment.second()->removeControlPoint1();
}
pathShape->normalize();
pathShape->update();
}
}
void KoPathPointInsertCommand::undo()
{
QUndoCommand::undo();
for (int i = 0; i < m_pointDataList.size(); ++i) {
const KoPathPointData &pdBefore = m_pointDataList.at(i);
KoPathShape * pathShape = pdBefore.pathShape;
KoPathPointIndex piAfter = pdBefore.pointIndex;
++piAfter.second;
KoPathPoint * before = pathShape->pointByIndex(pdBefore.pointIndex);
m_points[i] = pathShape->removePoint(piAfter);
if (m_points[i]->properties() & KoPathPoint::CloseSubpath) {
piAfter.second = 0;
}
KoPathPoint * after = pathShape->pointByIndex(piAfter);
if (before->activeControlPoint2()) {
QPointF controlPoint2 = before->controlPoint2();
qSwap(controlPoint2, m_controlPoints[i].first);
before->setControlPoint2(controlPoint2);
}
if (after->activeControlPoint1()) {
QPointF controlPoint1 = after->controlPoint1();
qSwap(controlPoint1, m_controlPoints[i].second);
after->setControlPoint1(controlPoint1);
}
pathShape->update();
}
m_deletePoints = true;
}
void KoPathPointInsertCommand::redo()
{
QUndoCommand::redo();
for (int i = m_pointDataList.size() - 1; i >= 0; --i) {
KoPathPointData pointData = m_pointDataList.at(i);
KoPathShape * pathShape = pointData.pathShape;
KoPathSegment segment = pathShape->segmentByIndex(pointData.pointIndex);
++pointData.pointIndex.second;
if (segment.first()->activeControlPoint2()) {
QPointF controlPoint2 = segment.first()->controlPoint2();
qSwap(controlPoint2, m_controlPoints[i].first);
segment.first()->setControlPoint2(controlPoint2);
}
if (segment.second()->activeControlPoint1()) {
QPointF controlPoint1 = segment.second()->controlPoint1();
qSwap(controlPoint1, m_controlPoints[i].second);
segment.second()->setControlPoint1(controlPoint1);
}
pathShape->insertPoint(m_points.at(i), pointData.pointIndex);
pathShape->update();
}
m_deletePoints = false;
}
void KoPathControlPointMoveCommand::redo()
{
KUndo2Command::redo();
KoPathShape * pathShape = m_pointData.pathShape;
KoPathPoint * point = pathShape->pointByIndex(m_pointData.pointIndex);
if (point) {
pathShape->update();
if (m_pointType == KoPathPoint::ControlPoint1) {
point->setControlPoint1(point->controlPoint1() + m_offset);
if (point->properties() & KoPathPoint::IsSymmetric) {
// set the other control point so that it lies on the line between the moved
// control point and the point, with the same distance to the point as the moved point
point->setControlPoint2(2.0 * point->point() - point->controlPoint1());
} else if (point->properties() & KoPathPoint::IsSmooth) {
// move the other control point so that it lies on the line through point and control point
// keeping its distance to the point
QPointF direction = point->point() - point->controlPoint1();
direction /= sqrt(direction.x() * direction.x() + direction.y() * direction.y());
QPointF distance = point->point() - point->controlPoint2();
qreal length = sqrt(distance.x() * distance.x() + distance.y() * distance.y());
point->setControlPoint2(point->point() + length * direction);
}
} else if (m_pointType == KoPathPoint::ControlPoint2) {
point->setControlPoint2(point->controlPoint2() + m_offset);
if (point->properties() & KoPathPoint::IsSymmetric) {
// set the other control point so that it lies on the line between the moved
// control point and the point, with the same distance to the point as the moved point
point->setControlPoint1(2.0 * point->point() - point->controlPoint2());
} else if (point->properties() & KoPathPoint::IsSmooth) {
// move the other control point so that it lies on the line through point and control point
// keeping its distance to the point
QPointF direction = point->point() - point->controlPoint2();
direction /= sqrt(direction.x() * direction.x() + direction.y() * direction.y());
QPointF distance = point->point() - point->controlPoint1();
qreal length = sqrt(distance.x() * distance.x() + distance.y() * distance.y());
point->setControlPoint1(point->point() + length * direction);
}
}
pathShape->normalize();
pathShape->update();
}
}
void KoSubpathJoinCommand::undo()
{
KUndo2Command::undo();
KoPathShape * pathShape = m_pointData1.pathShape;
pathShape->update();
if (m_pointData1.pointIndex.first == m_pointData2.pointIndex.first) {
pathShape->openSubpath(m_pointData1.pointIndex);
} else {
pathShape->breakAfter(m_splitIndex);
pathShape->moveSubpath(m_pointData1.pointIndex.first + 1, m_pointData2.pointIndex.first);
if (m_reverse & ReverseSecond) {
pathShape->reverseSubpath(m_pointData2.pointIndex.first);
}
if (m_reverse & ReverseFirst) {
pathShape->reverseSubpath(m_pointData1.pointIndex.first);
}
}
KoPathPoint * point1 = pathShape->pointByIndex(m_pointData1.pointIndex);
KoPathPoint * point2 = pathShape->pointByIndex(m_pointData2.pointIndex);
// restore the old end points
if (m_reverse & ReverseFirst)
point1->setControlPoint1(pathShape->documentToShape(m_oldControlPoint1));
else
point1->setControlPoint2(pathShape->documentToShape(m_oldControlPoint1));
point1->setProperties(m_oldProperties1);
if (m_reverse & ReverseSecond)
point2->setControlPoint1(pathShape->documentToShape(m_oldControlPoint2));
else
point2->setControlPoint2(pathShape->documentToShape(m_oldControlPoint2));
point2->setProperties(m_oldProperties2);
pathShape->normalize();
pathShape->update();
}
void KoSubpathJoinCommand::redo()
{
KUndo2Command::redo();
KoPathShape * pathShape = m_pointData1.pathShape;
bool closeSubpath = m_pointData1.pointIndex.first == m_pointData2.pointIndex.first;
KoPathPoint * point1 = pathShape->pointByIndex(m_pointData1.pointIndex);
KoPathPoint * point2 = pathShape->pointByIndex(m_pointData2.pointIndex);
// if the endpoint is has a control point create a contol point for the new segment to be
// at the symetric position to the exiting one
if (m_reverse & ReverseFirst || closeSubpath) {
if (point1->activeControlPoint2())
point1->setControlPoint1(2.0 * point1->point() - point1->controlPoint2());
} else if (point1->activeControlPoint1())
point1->setControlPoint2(2.0 * point1->point() - point1->controlPoint1());
if (m_reverse & ReverseSecond || closeSubpath) {
if (point2->activeControlPoint1())
point2->setControlPoint2(2.0 * point2->point() - point2->controlPoint1());
} else if (point2->activeControlPoint2())
point2->setControlPoint1(2.0 * point2->point() - point2->controlPoint2());
if (closeSubpath) {
pathShape->closeSubpath(m_pointData1.pointIndex);
} else {
if (m_reverse & ReverseFirst) {
pathShape->reverseSubpath(m_pointData1.pointIndex.first);
}
if (m_reverse & ReverseSecond) {
pathShape->reverseSubpath(m_pointData2.pointIndex.first);
}
pathShape->moveSubpath(m_pointData2.pointIndex.first, m_pointData1.pointIndex.first + 1);
m_splitIndex = m_pointData1.pointIndex;
m_splitIndex.second = pathShape->subpathPointCount(m_pointData1.pointIndex.first) - 1;
pathShape->join(m_pointData1.pointIndex.first);
}
pathShape->normalize();
pathShape->update();
}
