#include <qpathclipper_p.h>

Public Types
enum	Operation { BoolAnd, BoolOr, BoolSub, Simplify }

Public Functions
QPainterPath	clip (Operation op=BoolAnd)

bool	contains ()

bool	intersect ()

	QPathClipper (const QPainterPath &subject, const QPainterPath &clip)

Static Public Functions
static QPainterPath	intersect (const QPainterPath &path, const QRectF &rect)

static bool	pathToRect (const QPainterPath &path, QRectF *rect=0)

Private Types
enum	ClipperMode { ClipMode, CheckMode }

Private Functions
bool	doClip (QWingedEdge &list, ClipperMode mode)

bool	handleCrossingEdges (QWingedEdge &list, qreal y, ClipperMode mode)

Properties
int	aMask

int	bMask

QPainterPath	clipPath

Operation	op

QPainterPath	subjectPath

Detailed Description

Definition at line 71 of file qpathclipper_p.h.

Enumerations

◆ ClipperMode

enum QPathClipper::ClipperMode

private

Enumerator
ClipMode
CheckMode

Definition at line 95 of file qpathclipper_p.h.

                      {
         ClipMode, // do the full clip
         CheckMode // for contains/intersects (only interested in whether the result path is non-empty)
     };

◆ Operation

enum QPathClipper::Operation

Enumerator
BoolAnd
BoolOr
BoolSub
Simplify

Definition at line 74 of file qpathclipper_p.h.

                    {
         BoolAnd,
         BoolOr,
         BoolSub,
         Simplify
     };

Constructors and Destructors

◆ QPathClipper()

QPathClipper::QPathClipper	(	const QPainterPath &	subject,
		const QPainterPath &	clip
	)

Definition at line 1473 of file qpathclipper.cpp.

     : subjectPath(subject)
     , clipPath(clip)
 {
     aMask = subjectPath.fillRule() == Qt::WindingFill ? ~0x0 : 0x1;
     bMask = clipPath.fillRule() == Qt::WindingFill ? ~0x0 : 0x1;
 }

Functions

◆ clip()

QPainterPath QPathClipper::clip ( Operation op = BoolAnd )

Definition at line 1570 of file qpathclipper.cpp.

Referenced by QPainterPath::intersected(), QPainterPath::simplified(), QPainterPath::subtracted(), and QPainterPath::united().

 {
     op = operation;
 
     if (op != Simplify) {
         if (subjectPath == clipPath)
             return op == BoolSub ? QPainterPath() : subjectPath;
 
         bool subjectIsRect = pathToRect(subjectPath, 0);
         bool clipIsRect = pathToRect(clipPath, 0);
 
         const QRectF clipBounds = clipPath.boundingRect();
         const QRectF subjectBounds = subjectPath.boundingRect();
 
         if (!clipBounds.intersects(subjectBounds)) {
             switch (op) {
             case BoolSub:
                 return subjectPath;
             case BoolAnd:
                 return QPainterPath();
             case BoolOr: {
                 QPainterPath result = subjectPath;
                 if (result.fillRule() == clipPath.fillRule()) {
                     result.addPath(clipPath);
                 } else if (result.fillRule() == Qt::WindingFill) {
                     result = result.simplified();
                     result.addPath(clipPath);
                 } else {
                     result.addPath(clipPath.simplified());
                 }
                 return result;
              }
             default:
                 break;
             }
         }
 
         if (clipBounds.contains(subjectBounds)) {
             if (clipIsRect) {
                 switch (op) {
                 case BoolSub:
                     return QPainterPath();
                 case BoolAnd:
                     return subjectPath;
                 case BoolOr:
                     return clipPath;
                 default:
                     break;
                 }
             }
         } else if (subjectBounds.contains(clipBounds)) {
             if (subjectIsRect) {
                 switch (op) {
                 case BoolSub:
                     if (clipPath.fillRule() == Qt::OddEvenFill) {
                         QPainterPath result = clipPath;
                         result.addRect(subjectBounds);
                         return result;
                     } else {
                         QPainterPath result = clipPath.simplified();
                         result.addRect(subjectBounds);
                         return result;
                     }
                     break;
                 case BoolAnd:
                     return clipPath;
                 case BoolOr:
                     return subjectPath;
                 default:
                     break;
                 }
             }
         }
 
         if (op == BoolAnd) {
             if (subjectIsRect)
                 return intersect(clipPath, subjectBounds);
             else if (clipIsRect)
                 return intersect(subjectPath, clipBounds);
         }
     }
 
     QWingedEdge list(subjectPath, clipPath);
 
     doClip(list, ClipMode);
 
     QPainterPath path = list.toPath();
     return path;
 }

◆ contains()

bool QPathClipper::contains ( )

Definition at line 1436 of file qpathclipper.cpp.

Referenced by QPainterPath::contains().

 {
     if (subjectPath == clipPath)
         return false;
 
     QRectF r1 = subjectPath.controlPointRect();
     QRectF r2 = clipPath.controlPointRect();
     if (qMax(r1.x(), r2.x()) > qMin(r1.x() + r1.width(), r2.x() + r2.width()) ||
         qMax(r1.y(), r2.y()) > qMin(r1.y() + r1.height(), r2.y() + r2.height())) {
         // no intersection -> not contained
         return false;
     }
 
     bool clipIsRect = pathToRect(clipPath);
     if (clipIsRect)
         return subjectPath.contains(r2);
 
     QPathSegments a(subjectPath.elementCount());
     a.setPath(subjectPath);
     QPathSegments b(clipPath.elementCount());
     b.setPath(clipPath);
 
     QIntersectionFinder finder;
     if (finder.hasIntersections(a, b))
         return false;
 
     for (int i = 0; i < clipPath.elementCount(); ++i) {
         if (clipPath.elementAt(i).type == QPainterPath::MoveToElement) {
             const QPointF point = clipPath.elementAt(i);
             if (!r1.contains(point) || !subjectPath.contains(point))
                 return false;
         }
     }
 
     return true;
 }

◆ doClip()

bool QPathClipper::doClip	(	QWingedEdge &	list,
		ClipperMode	mode
	)

private

Definition at line 1660 of file qpathclipper.cpp.

Referenced by clip().

 {
     QVector<qreal> y_coords;
     y_coords.reserve(list.vertexCount());
     for (int i = 0; i < list.vertexCount(); ++i)
         y_coords << list.vertex(i)->y;
 
     qSort(y_coords.begin(), y_coords.end());
     y_coords.resize(qRemoveDuplicates(y_coords.begin(), y_coords.end(), fuzzyCompare) - y_coords.begin());
 
 #ifdef QDEBUG_CLIPPER
     printf("sorted y coords:\n");
     for (int i = 0; i < y_coords.size(); ++i) {
         printf("%.9f\n", y_coords[i]);
     }
 #endif
 
     bool found;
     do {
         found = false;
         int index = 0;
         qreal maxHeight = 0;
         for (int i = 0; i < list.edgeCount(); ++i) {
             QPathEdge *edge = list.edge(i);
 
             // have both sides of this edge already been handled?
             if ((edge->flag & 0x3) == 0x3)
                 continue;
 
             QPathVertex *a = list.vertex(edge->first);
             QPathVertex *b = list.vertex(edge->second);
 
             if (qFuzzyCompare(a->y, b->y))
                 continue;
 
             found = true;
 
             qreal height = qAbs(a->y - b->y);
             if (height > maxHeight) {
                 index = i;
                 maxHeight = height;
             }
         }
 
         if (found) {
             QPathEdge *edge = list.edge(index);
 
             QPathVertex *a = list.vertex(edge->first);
             QPathVertex *b = list.vertex(edge->second);
 
             // FIXME: this can be optimized by using binary search
             const int first = qFuzzyFind(y_coords.begin(), y_coords.end(), qMin(a->y, b->y)) - y_coords.begin();
             const int last = qFuzzyFind(y_coords.begin() + first, y_coords.end(), qMax(a->y, b->y)) - y_coords.begin();
 
             Q_ASSERT(first < y_coords.size() - 1);
             Q_ASSERT(last < y_coords.size());
 
             qreal bestY = 0.5 * (y_coords[first] + y_coords[first+1]);
             qreal biggestGap = y_coords[first+1] - y_coords[first];
 
             for (int i = first + 1; i < last; ++i) {
                 qreal gap = y_coords[i+1] - y_coords[i];
 
                 if (gap > biggestGap) {
                     bestY = 0.5 * (y_coords[i] + y_coords[i+1]);
                     biggestGap = gap;
                 }
             }
 
 #ifdef QDEBUG_CLIPPER
             printf("y: %.9f, gap: %.9f\n", bestY, biggestGap);
 #endif
 
             if (handleCrossingEdges(list, bestY, mode) && mode == CheckMode)
                 return true;
 
             edge->flag |= 0x3;
         }
     } while (found);
 
     if (mode == ClipMode)
         list.simplify();
 
     return false;
 }

◆ handleCrossingEdges()

bool QPathClipper::handleCrossingEdges	(	QWingedEdge &	list,
		qreal	y,
		ClipperMode	mode
	)

private

Definition at line 1838 of file qpathclipper.cpp.

Referenced by doClip().

 {
     QVector<QCrossingEdge> crossings = findCrossings(list, y);
 
     Q_ASSERT(!crossings.isEmpty());
     qSort(crossings.begin(), crossings.end());
 
     int windingA = 0;
     int windingB = 0;
 
     int windingD = 0;
 
 #ifdef QDEBUG_CLIPPER
     qDebug() << "crossings:" << crossings.size();
 #endif
     for (int i = 0; i < crossings.size() - 1; ++i) {
         int ei = crossings.at(i).edge;
         const QPathEdge *edge = list.edge(ei);
 
         windingA += edge->windingA;
         windingB += edge->windingB;
 
         const bool hasLeft = (edge->flag >> 4) & 1;
         const bool hasRight = (edge->flag >> 4) & 2;
 
         windingD += hasLeft ^ hasRight;
 
         const bool inA = (windingA & aMask) != 0;
         const bool inB = (windingB & bMask) != 0;
         const bool inD = (windingD & 0x1) != 0;
 
         const bool inside = bool_op(inA, inB, op);
         const bool add = inD ^ inside;
 
 #ifdef QDEBUG_CLIPPER
         printf("y %f, x %f, inA: %d, inB: %d, inD: %d, inside: %d, flag: %x, bezier: %p, edge: %d\n", y, crossings.at(i).x, inA, inB, inD, inside, edge->flag, edge->bezier, ei);
 #endif
 
         if (add) {
             if (mode == CheckMode)
                 return true;
 
             qreal y0 = list.vertex(edge->first)->y;
             qreal y1 = list.vertex(edge->second)->y;
 
             if (y0 < y1) {
                 if (!(edge->flag & 1))
                     traverse(list, ei, QPathEdge::LeftTraversal);
 
                 if (!(edge->flag & 2))
                     clear(list, ei, QPathEdge::RightTraversal);
             } else {
                 if (!(edge->flag & 1))
                     clear(list, ei, QPathEdge::LeftTraversal);
 
                 if (!(edge->flag & 2))
                     traverse(list, ei, QPathEdge::RightTraversal);
             }
 
             ++windingD;
         } else {
             if (!(edge->flag & 1))
                 clear(list, ei, QPathEdge::LeftTraversal);
 
             if (!(edge->flag & 2))
                 clear(list, ei, QPathEdge::RightTraversal);
         }
     }
 
     return false;
 }

◆ intersect() [1/2]

bool QPathClipper::intersect ( )

Definition at line 1385 of file qpathclipper.cpp.

Referenced by clip(), and QPainterPath::intersects().

 {
     if (subjectPath == clipPath)
         return true;
 
     QRectF r1 = subjectPath.controlPointRect();
     QRectF r2 = clipPath.controlPointRect();
     if (qMax(r1.x(), r2.x()) > qMin(r1.x() + r1.width(), r2.x() + r2.width()) ||
         qMax(r1.y(), r2.y()) > qMin(r1.y() + r1.height(), r2.y() + r2.height())) {
         // no way we could intersect
         return false;
     }
 
     bool subjectIsRect = pathToRect(subjectPath);
     bool clipIsRect = pathToRect(clipPath);
 
     if (subjectIsRect && clipIsRect)
         return true;
     else if (subjectIsRect)
         return clipPath.intersects(r1);
     else if (clipIsRect)
         return subjectPath.intersects(r2);
 
     QPathSegments a(subjectPath.elementCount());
     a.setPath(subjectPath);
     QPathSegments b(clipPath.elementCount());
     b.setPath(clipPath);
 
     QIntersectionFinder finder;
     if (finder.hasIntersections(a, b))
         return true;
 
     for (int i = 0; i < clipPath.elementCount(); ++i) {
         if (clipPath.elementAt(i).type == QPainterPath::MoveToElement) {
             const QPointF point = clipPath.elementAt(i);
             if (r1.contains(point) && subjectPath.contains(point))
                 return true;
         }
     }
 
     for (int i = 0; i < subjectPath.elementCount(); ++i) {
         if (subjectPath.elementAt(i).type == QPainterPath::MoveToElement) {
             const QPointF point = subjectPath.elementAt(i);
             if (r2.contains(point) && clipPath.contains(point))
                 return true;
         }
     }
 
     return false;
 }

◆ intersect() [2/2]

QPainterPath QPathClipper::intersect	(	const QPainterPath &	path,
		const QRectF &	rect
	)

static

Definition at line 2144 of file qpathclipper.cpp.

 {
     return intersectPath(path, rect);
 }

◆ pathToRect()

bool QPathClipper::pathToRect	(	const QPainterPath &	path,
		QRectF *	rect = `0`
	)

static

Definition at line 1531 of file qpathclipper.cpp.

Referenced by clip(), and setClip().

 {
     if (path.elementCount() != 5)
         return false;
 
     const bool mightBeRect = path.elementAt(0).isMoveTo()
         && path.elementAt(1).isLineTo()
         && path.elementAt(2).isLineTo()
         && path.elementAt(3).isLineTo()
         && path.elementAt(4).isLineTo();
 
     if (!mightBeRect)
         return false;
 
     const qreal x1 = path.elementAt(0).x;
     const qreal y1 = path.elementAt(0).y;
 
     const qreal x2 = path.elementAt(1).x;
     const qreal y2 = path.elementAt(2).y;
 
     if (path.elementAt(1).y != y1)
         return false;
 
     if (path.elementAt(2).x != x2)
         return false;
 
     if (path.elementAt(3).x != x1 || path.elementAt(3).y != y2)
         return false;
 
     if (path.elementAt(4).x != x1 || path.elementAt(4).y != y1)
         return false;
 
     if (rect)
         rect->setCoords(x1, y1, x2, y2);
 
     return true;
 }

Properties

◆ aMask

int QPathClipper::aMask

private

Definition at line 107 of file qpathclipper_p.h.

Referenced by handleCrossingEdges(), and QPathClipper().

◆ bMask

int QPathClipper::bMask

private

Definition at line 108 of file qpathclipper_p.h.

Referenced by handleCrossingEdges(), and QPathClipper().

◆ clipPath

QPainterPath QPathClipper::clipPath

private

Definition at line 104 of file qpathclipper_p.h.

Referenced by clip(), and QPathClipper().

◆ op

Operation QPathClipper::op

private

Definition at line 105 of file qpathclipper_p.h.

Referenced by clip(), and handleCrossingEdges().

◆ subjectPath

QPainterPath QPathClipper::subjectPath

private

Definition at line 103 of file qpathclipper_p.h.

Referenced by clip(), and QPathClipper().

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

/src/gui/painting/qpathclipper_p.h
/src/gui/painting/qpathclipper.cpp

Public Types

Public Functions

Static Public Functions

Private Types

Private Functions

Properties

Detailed Description

Enumerations

◆ ClipperMode

◆ Operation

Constructors and Destructors

◆ QPathClipper()

Functions

◆ clip()

◆ contains()

◆ doClip()

◆ handleCrossingEdges()

◆ intersect() [1/2]

◆ intersect() [2/2]

◆ pathToRect()

Properties

◆ aMask

◆ bMask

◆ clipPath

◆ op

◆ subjectPath