Warning, file /office/calligra/libs/textlayout/KoTextLayoutObstruction.cpp was not indexed or was modified since last indexation (in which case cross-reference links may be missing, inaccurate or erroneous).

 /* This file is part of the KDE project
  * Copyright (C) 2006-2007, 2010 Thomas Zander <zander@kde.org>
  * Copyright (C) 2010 Ko Gmbh <cbo@kogmbh.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "KoTextLayoutObstruction.h"
 
 #include <KoShapeStrokeModel.h>
 #include <KoShapeShadow.h>
 #include <KoShapeGroup.h>
 #include <KoClipPath.h>
 #include <KoInsets.h>
 
 #include <QTransform>
 #include <QPainterPath>
 
 KoTextLayoutObstruction::KoTextLayoutObstruction(KoShape *shape, const QTransform &matrix)
     : m_side(None),
     m_polygon(QPolygonF()),
     m_line(QRectF()),
     m_shape(shape),
     m_runAroundThreshold(0)
 {
     qreal borderHalfWidth;
     QPainterPath path = decoratedOutline(m_shape, borderHalfWidth);
 
     //TODO check if path is convex. otherwise do triangulation and create more convex obstructions
     init(matrix, path, shape->textRunAroundDistanceLeft(), shape->textRunAroundDistanceTop(), shape->textRunAroundDistanceRight(), shape->textRunAroundDistanceBottom(), borderHalfWidth);
 
     if (shape->textRunAroundSide() == KoShape::NoRunAround) {
         // make the shape take the full width of the text area
         m_side = Empty;
     } else if (shape->textRunAroundSide() == KoShape::RunThrough) {
         m_distanceLeft = 0;
         m_distanceTop = 0;
         m_distanceRight = 0;
         m_distanceBottom = 0;
         // We don't exist.
         return;
     } else if (shape->textRunAroundSide() == KoShape::LeftRunAroundSide) {
         m_side = Left;
     } else if (shape->textRunAroundSide() == KoShape::RightRunAroundSide) {
         m_side = Right;
     } else if (shape->textRunAroundSide() == KoShape::BothRunAroundSide) {
         m_side = Both;
     } else if (shape->textRunAroundSide() == KoShape::BiggestRunAroundSide) {
         m_side = Bigger;
     } else if (shape->textRunAroundSide() == KoShape::EnoughRunAroundSide) {
         m_side = Enough;
         m_runAroundThreshold = shape->textRunAroundThreshold();
     }
 }
 
 KoTextLayoutObstruction::KoTextLayoutObstruction(const QRectF &rect, bool rtl)
     : m_side(None),
     m_polygon(QPolygonF()),
     m_line(QRectF()),
     m_shape(0),
     m_runAroundThreshold(0)
 {
     qreal borderHalfWidth = 0;
     qreal textRunAroundDistance = 1;
 
     QPainterPath path;
     path.addRect(rect);
 
     init(QTransform(), path, textRunAroundDistance, 0.0, textRunAroundDistance, 0.0,  borderHalfWidth);
     if (rtl) {
         m_side = Right;
     } else {
         m_side = Left;
     }
 }
 
 QPainterPath KoTextLayoutObstruction::decoratedOutline(const KoShape *shape, qreal &borderHalfWidth) const
 {
     const KoShapeGroup *shapeGroup = dynamic_cast<const KoShapeGroup *>(shape);
     if (shapeGroup) {
         QPainterPath groupPath;
 
         foreach (const KoShape *child, shapeGroup->shapes()) {
             groupPath += decoratedOutline(child, borderHalfWidth);
         }
         return groupPath;
     }
 
     QPainterPath path;
     if (shape->textRunAroundContour() != KoShape::ContourBox) {
         KoClipPath *clipPath = shape->clipPath();
         if (clipPath) {
             path = clipPath->pathForSize(shape->size());
         } else {
             path = shape->outline();
         }
     } else {
         path.addRect(shape->outlineRect());
     }
 
     QRectF bb = shape->outlineRect();
     borderHalfWidth = 0;
  
     if (shape->stroke()) {
         KoInsets insets;
         shape->stroke()->strokeInsets(shape, insets);
         /*
         bb.adjust(-insets.left, -insets.top, insets.right, insets.bottom);
         path = QPainterPath();
         path.addRect(bb);
         */
         borderHalfWidth = qMax(qMax(insets.left, insets.top),qMax(insets.right, insets.bottom));
     }
 
     if (shape->shadow() && shape->shadow()->isVisible()) {
         QTransform transform = shape->absoluteTransformation(0);
         bb = transform.mapRect(bb);
         KoInsets insets;
         shape->shadow()->insets(insets);
         bb.adjust(-insets.left, -insets.top, insets.right, insets.bottom);
         path = QPainterPath();
         path.addRect(bb);
         path = transform.inverted().map(path);
     }
 
     return path;
 }
 
 void KoTextLayoutObstruction::init(const QTransform &matrix, const QPainterPath &obstruction, qreal distanceLeft, qreal distanceTop, qreal distanceRight, qreal distanceBottom, qreal borderHalfWidth)
 {
     m_distanceLeft = distanceLeft;
     m_distanceTop = distanceTop;
     m_distanceRight = distanceRight;
     m_distanceBottom = distanceBottom;
     QPainterPath path =  matrix.map(obstruction);
     distanceLeft += borderHalfWidth;
     distanceTop += borderHalfWidth;
     distanceRight += borderHalfWidth;
     distanceBottom += borderHalfWidth;
 
     qreal extraWidth = distanceLeft + distanceRight;
     qreal extraHeight = distanceTop + distanceBottom;
     if (extraWidth != 0.0 || extraHeight != 0.0) {
         // Let's extend the outline with at least the border half width in all directions.
         // However since the distance can be express in 4 directions and QPainterPathStroker only
         // handles a penWidth we do some tricks to get it working.
         //
         // Explanation in one dimension only: we sum the distances top and below and use that as the
         // penWidth. afterwards we translate the result so it is distributed correctly by top and bottom
         // Now by doing that we would also implicitly set the left+right size of the pen which is no good,
         // so in order to set that to a minimal value (we choose 1, as 0 would give division by 0) we do
         // the following:. We scale the original path by sumX, stroke the path with penwidth=sumY, then
         // scale it back. Effectively we have now stroked with a pen sized 1 x sumY.
         //
         // The math to do both x an y in one go becomes a little more complex, but only a little.
         extraWidth = qMax(qreal(0.1), extraWidth);
         extraHeight = qMax(qreal(0.1), extraHeight);
 
         QPainterPathStroker stroker;
         stroker.setWidth(extraWidth);
         stroker.setJoinStyle(Qt::MiterJoin);
         stroker.setCapStyle(Qt::SquareCap);
         QPainterPath bigPath = stroker.createStroke(QTransform().scale(1.0, extraWidth / extraHeight).map(path));
         bigPath = QTransform().scale(1.0, extraHeight / extraWidth). map(bigPath);
         path += bigPath.translated(extraWidth / 2 - distanceLeft, extraHeight / 2 - distanceTop);
     }
 
     m_bounds = path.boundingRect();
 
     // Now we need to change the path into a polygon for easier handling later on
     m_polygon = path.toFillPolygon();
     QPointF &prev(m_polygon.first());
     // There exists a problem on msvc with for(each) and QVector<QPointF>
     for (int i = 0; i < m_polygon.count(); ++i) {
         const QPointF &vtx(m_polygon[i]);
         if (vtx.x() == prev.x() && vtx.y() == prev.y())
             continue;
         QLineF line;
         if (prev.y() < vtx.y()) // Make sure the vector lines all point downwards.
             line = QLineF(prev, vtx);
         else
             line = QLineF(vtx, prev);
         m_edges.insert(line.y1(), line);
         prev = vtx;
     }
 }
 
 qreal KoTextLayoutObstruction::xAtY(const QLineF &line, qreal y)
 {
     if (line.dx() == 0)
         return line.x1();
     return line.x1() + (y - line.y1()) / line.dy() * line.dx();
 }
 
 void KoTextLayoutObstruction::changeMatrix(const QTransform &matrix)
 {
     m_edges.clear();
 
     qreal borderHalfWidth;
     QPainterPath path = decoratedOutline(m_shape, borderHalfWidth);
 
     init(matrix, path, m_distanceLeft, m_distanceTop, m_distanceRight, m_distanceBottom, borderHalfWidth);
 }
 
 QRectF KoTextLayoutObstruction::cropToLine(const QRectF &lineRect)
 {
     if (m_bounds.intersects(lineRect)) {
         m_line = lineRect;
         bool untilFirst = true;
         //check inner points
         // There exists a problem on msvc with for(each) and QVector<QPointF>
         for (int i = 0; i < m_polygon.count(); ++i) {
             const QPointF point(m_polygon[i]);
             if (lineRect.contains(point)) {
                 if (untilFirst) {
                     m_line.setLeft(point.x());
                     m_line.setRight(point.x());
                     untilFirst = false;
                 } else {
                     if (point.x() < m_line.left()) {
                         m_line.setLeft(point.x());
                     } else if (point.x() > m_line.right()) {
                         m_line.setRight(point.x());
                     }
                 }
             }
         }
         //check edges
         qreal points[2] = { lineRect.top(), lineRect.bottom() };
         for (int i = 0; i < 2; i++) {
             const qreal y = points[i];
             QMap<qreal, QLineF>::const_iterator iter = m_edges.constBegin();
             for (;iter != m_edges.constEnd(); ++iter) {
                 QLineF line = iter.value();
                 if (line.y2() < y) // not a section that will intersect with ou Y yet
                     continue;
                 if (line.y1() > y) // section is below our Y, so abort loop
                     //break;
                     continue;
                 if (qAbs(line.dy()) < 1E-10)  // horizontal lines don't concern us.
                     continue;
 
                 qreal intersect = xAtY(iter.value(), y);
                 if (untilFirst) {
                     m_line.setLeft(intersect);
                     m_line.setRight(intersect);
                     untilFirst = false;
                 } else {
                     if (intersect < m_line.left()) {
                         m_line.setLeft(intersect);
                     } else if (intersect > m_line.right()) {
                         m_line.setRight(intersect);
                     }
                 }
             }
         }
     } else {
         m_line = QRectF();
     }
     return m_line;
 }
 
 QRectF KoTextLayoutObstruction::getLeftLinePart(const QRectF &lineRect) const
 {
     QRectF leftLinePart = lineRect;
     leftLinePart.setRight(m_line.left());
     return leftLinePart;
 }
 
 QRectF KoTextLayoutObstruction::getRightLinePart(const QRectF &lineRect) const
 {
     QRectF rightLinePart = lineRect;
     if (m_line.right() > rightLinePart.left()) {
         rightLinePart.setLeft(m_line.right());
     }
     return rightLinePart;
 }
 
 bool KoTextLayoutObstruction::textOnLeft() const
 {    
     return  m_side == Left;
 }
 
 bool KoTextLayoutObstruction::textOnRight() const
 {
     return m_side == Right;
 }
 
 bool KoTextLayoutObstruction::textOnBiggerSide() const
 {
     return m_side == Bigger;
 }
 
 bool KoTextLayoutObstruction::textOnEnoughSides() const
 {
     return m_side == Enough;
 }
 
 qreal KoTextLayoutObstruction::runAroundThreshold() const
 {
     return m_runAroundThreshold;
 }
 
 bool KoTextLayoutObstruction::noTextAround() const
 {
     return m_side == Empty;
 }
 
 bool KoTextLayoutObstruction::compareRectLeft(KoTextLayoutObstruction *o1, KoTextLayoutObstruction *o2)
 {
     return o1->m_line.left() < o2->m_line.left();
 }