#include <qoutlinemapper_p.h>

Public Functions
void	beginOutline (Qt::FillRule fillRule)

void	clipElements (const QPointF points, const QPainterPath::ElementType types, int count)

void	closeSubpath ()

void	convertElements (const QPointF points, const QPainterPath::ElementType types, int count)

QT_FT_Outline *	convertPath (const QPainterPath &path)

QT_FT_Outline *	convertPath (const QVectorPath &path)

void	curveTo (const QPointF &cp1, const QPointF &cp2, const QPointF &ep)

QPainterPath::ElementType *	elementTypes () const

void	endOutline ()

void	lineTo (const QPointF &pt)

void	moveTo (const QPointF &pt)

QT_FT_Outline *	outline ()

	QOutlineMapper ()

void	setMatrix (const QTransform &m)
	Sets up the matrix to be used for conversion. More...

Public Variables
QRectF	controlPointRect

QRect	m_clip_rect

QDataBuffer< int >	m_contours

qreal	m_dx

qreal	m_dy

QDataBuffer< QPainterPath::ElementType >	m_element_types

QDataBuffer< QPointF >	m_elements

QDataBuffer< QPointF >	m_elements_dev

bool	m_in_clip_elements

qreal	m_m11

qreal	m_m12

qreal	m_m13

qreal	m_m21

qreal	m_m22

qreal	m_m23

qreal	m_m33

QT_FT_Outline	m_outline

QDataBuffer< QT_FT_Vector >	m_points

QDataBuffer< QPointF >	m_polygon_dev

int	m_subpath_start

QDataBuffer< char >	m_tags

uint	m_txop

bool	m_valid

Detailed Description

Definition at line 87 of file qoutlinemapper_p.h.

Constructors and Destructors

◆ QOutlineMapper()

QOutlineMapper::QOutlineMapper ( )

inline

Definition at line 90 of file qoutlinemapper_p.h.

                      :
         m_element_types(0),
         m_elements(0),
         m_elements_dev(0),
         m_points(0),
         m_tags(0),
         m_contours(0),
         m_polygon_dev(0),
         m_in_clip_elements(false)
     {
     }

Functions

◆ beginOutline()

void QOutlineMapper::beginOutline ( Qt::FillRule fillRule )

inline

Definition at line 121 of file qoutlinemapper_p.h.

Referenced by convertPath(), and QRasterPaintEngine::drawPolygon().

     {
 #ifdef QT_DEBUG_CONVERT
         printf("QOutlineMapper::beginOutline rule=%d\n", fillRule);
 #endif
         m_valid = true;
         m_elements.reset();
         m_elements_dev.reset();
         m_element_types.reset();
         m_points.reset();
         m_tags.reset();
         m_contours.reset();
         m_outline.flags = fillRule == Qt::WindingFill
                           ? QT_FT_OUTLINE_NONE
                           : QT_FT_OUTLINE_EVEN_ODD_FILL;
         m_subpath_start = 0;
     }

◆ clipElements()

void QOutlineMapper::clipElements	(	const QPointF *	points,
		const QPainterPath::ElementType *	types,
		int	count
	)

Definition at line 341 of file qoutlinemapper.cpp.

Referenced by beginOutline(), and endOutline().

 {
     // We could save a bit of time by actually implementing them fully
     // instead of going through convenience functionallity, but since
     // this part of code hardly every used, it shouldn't matter.
 
     m_in_clip_elements = true;
 
     QPainterPath path;
 
     if (!(m_outline.flags & QT_FT_OUTLINE_EVEN_ODD_FILL))
         path.setFillRule(Qt::WindingFill);
 
     if (types) {
         for (int i=0; i<element_count; ++i) {
             switch (types[i]) {
             case QPainterPath::MoveToElement:
                 path.moveTo(elements[i]);
                 break;
 
             case QPainterPath::LineToElement:
                 path.lineTo(elements[i]);
                 break;
 
             case QPainterPath::CurveToElement:
                 path.cubicTo(elements[i], elements[i+1], elements[i+2]);
                 i += 2;
                 break;
             default:
                 break;
             }
         }
     } else {
         path.moveTo(elements[0]);
         for (int i=1; i<element_count; ++i)
             path.lineTo(elements[i]);
     }
 
     QPainterPath clipPath;
     clipPath.addRect(m_clip_rect);
     QPainterPath clippedPath = path.intersected(clipPath);
     uint old_txop = m_txop;
     m_txop = QTransform::TxNone;
     if (clippedPath.isEmpty())
         m_valid = false;
     else
         convertPath(clippedPath);
     m_txop = old_txop;
 
     m_in_clip_elements = false;
 }

◆ closeSubpath()

void QOutlineMapper::closeSubpath ( )

inline

Definition at line 173 of file qoutlinemapper_p.h.

Referenced by endOutline(), and moveTo().

                                {
         int element_count = m_elements.size();
         if (element_count > 0) {
             if (m_elements.at(element_count-1) != m_elements.at(m_subpath_start)) {
 #ifdef QT_DEBUG_CONVERT
                 printf(" - implicitly closing\n");
 #endif
                 // Put the object on the stack to avoid the odd case where
                 // lineTo reallocs the databuffer and the QPointF & will
                 // be invalidated.
                 QPointF pt = m_elements.at(m_subpath_start);
 
                 // only do lineTo if we have element_type array...
                 if (m_element_types.size())
                     lineTo(pt);
                 else
                     m_elements << pt;
 
             }
         }
     }

◆ convertElements()

void QOutlineMapper::convertElements	(	const QPointF *	points,
		const QPainterPath::ElementType *	types,
		int	count
	)

Definition at line 244 of file qoutlinemapper.cpp.

Referenced by beginOutline(), and endOutline().

 {
 
     if (types) {
         // Translate into FT coords
         const QPointF *e = elements;
         for (int i=0; i<element_count; ++i) {
             switch (*types) {
             case QPainterPath::MoveToElement:
                 {
                     QT_FT_Vector pt_fixed = { qreal_to_fixed_26_6(e->x()),
                                               qreal_to_fixed_26_6(e->y()) };
                     if (i != 0)
                         m_contours << m_points.size() - 1;
                     m_points << pt_fixed;
                     m_tags <<  QT_FT_CURVE_TAG_ON;
                 }
                 break;
 
             case QPainterPath::LineToElement:
                 {
                     QT_FT_Vector pt_fixed = { qreal_to_fixed_26_6(e->x()),
                                               qreal_to_fixed_26_6(e->y()) };
                     m_points << pt_fixed;
                     m_tags << QT_FT_CURVE_TAG_ON;
                 }
                 break;
 
             case QPainterPath::CurveToElement:
                 {
                     QT_FT_Vector cp1_fixed = { qreal_to_fixed_26_6(e->x()),
                                                qreal_to_fixed_26_6(e->y()) };
                     ++e;
                     QT_FT_Vector cp2_fixed = { qreal_to_fixed_26_6((e)->x()),
                                                qreal_to_fixed_26_6((e)->y()) };
                     ++e;
                     QT_FT_Vector ep_fixed = { qreal_to_fixed_26_6((e)->x()),
                                               qreal_to_fixed_26_6((e)->y()) };
 
                     m_points << cp1_fixed << cp2_fixed << ep_fixed;
                     m_tags << QT_FT_CURVE_TAG_CUBIC
                            << QT_FT_CURVE_TAG_CUBIC
                            << QT_FT_CURVE_TAG_ON;
 
                     types += 2;
                     i += 2;
                 }
                 break;
             default:
                 break;
             }
             ++types;
             ++e;
         }
     } else {
         // Plain polygon...
         const QPointF *last = elements + element_count;
         const QPointF *e = elements;
         while (e < last) {
             QT_FT_Vector pt_fixed = { qreal_to_fixed_26_6(e->x()),
                                       qreal_to_fixed_26_6(e->y()) };
             m_points << pt_fixed;
             m_tags << QT_FT_CURVE_TAG_ON;
             ++e;
         }
     }
 
     // close the very last subpath
     m_contours << m_points.size() - 1;
 
     m_outline.n_contours = m_contours.size();
     m_outline.n_points = m_points.size();
 
     m_outline.points = m_points.data();
     m_outline.tags = m_tags.data();
     m_outline.contours = m_contours.data();
 
 #ifdef QT_DEBUG_CONVERT
     printf("QOutlineMapper::endOutline\n");
 
     printf(" - contours: %d\n", m_outline.n_contours);
     for (int i=0; i<m_outline.n_contours; ++i) {
         printf("   - %d\n", m_outline.contours[i]);
     }
 
     printf(" - points: %d\n", m_outline.n_points);
     for (int i=0; i<m_outline.n_points; ++i) {
         printf("   - %d -- %.2f, %.2f, (%d, %d)\n", i,
                (double) (m_outline.points[i].x / 64.0),
                (double) (m_outline.points[i].y / 64.0),
                (int) m_outline.points[i].x, (int) m_outline.points[i].y);
     }
 #endif
 }

◆ convertPath() [1/2]

QT_FT_Outline * QOutlineMapper::convertPath ( const QPainterPath & path )

Definition at line 78 of file qoutlinemapper.cpp.

Referenced by QRasterPaintEngine::clip(), clipElements(), endOutline(), QRasterPaintEngine::fill(), QRasterPaintEngine::fillPath(), QRasterPaintEngine::fillPolygon(), and outline().

 {
     Q_ASSERT(!path.isEmpty());
     int elmCount = path.elementCount();
 #ifdef QT_DEBUG_CONVERT
     printf("QOutlineMapper::convertPath(), size=%d\n", elmCount);
 #endif
     beginOutline(path.fillRule());
 
     for (int index=0; index<elmCount; ++index) {
         const QPainterPath::Element &elm = path.elementAt(index);
 
         switch (elm.type) {
 
         case QPainterPath::MoveToElement:
             if (index == elmCount - 1)
                 continue;
             moveTo(elm);
             break;
 
         case QPainterPath::LineToElement:
             lineTo(elm);
             break;
 
         case QPainterPath::CurveToElement:
             curveTo(elm, path.elementAt(index + 1), path.elementAt(index + 2));
             index += 2;
             break;
 
         default:
             break; // This will never hit..
         }
     }
 
     endOutline();
     return outline();
 }

◆ convertPath() [2/2]

QT_FT_Outline * QOutlineMapper::convertPath ( const QVectorPath & path )

Definition at line 116 of file qoutlinemapper.cpp.

 {
     int count = path.elementCount();
 
 #ifdef QT_DEBUG_CONVERT
     printf("QOutlineMapper::convertPath(VP), size=%d\n", count);
 #endif
     beginOutline(path.hasWindingFill() ? Qt::WindingFill : Qt::OddEvenFill);
 
     if (path.elements()) {
         // TODO: if we do closing of subpaths in convertElements instead we
         // could avoid this loop
         const QPainterPath::ElementType *elements = path.elements();
         const QPointF *points = reinterpret_cast<const QPointF *>(path.points());
 
         for (int index = 0; index < count; ++index) {
             switch (elements[index]) {
                 case QPainterPath::MoveToElement:
                     if (index == count - 1)
                         continue;
                     moveTo(points[index]);
                     break;
 
                 case QPainterPath::LineToElement:
                     lineTo(points[index]);
                     break;
 
                 case QPainterPath::CurveToElement:
                     curveTo(points[index], points[index+1], points[index+2]);
                     index += 2;
                     break;
 
                 default:
                     break; // This will never hit..
             }
         }
 
     } else {
         // ### We can kill this copying and just use the buffer straight...
 
         m_elements.resize(count);
         if (count)
             memcpy(m_elements.data(), path.points(), count* sizeof(QPointF));
 
         m_element_types.resize(0);
     }
 
     endOutline();
     return outline();
 }

◆ curveTo()

void QOutlineMapper::curveTo	(	const QPointF &	cp1,
		const QPointF &	cp2,
		const QPointF &	ep
	)

inline

Definition at line 163 of file qoutlinemapper_p.h.

Referenced by convertPath().

                                                                                    {
 #ifdef QT_DEBUG_CONVERT
         printf("QOutlineMapper::curveTo() (%f, %f)\n", ep.x(), ep.y());
 #endif
         m_elements << cp1 << cp2 << ep;
         m_element_types << QPainterPath::CurveToElement
                         << QPainterPath::CurveToDataElement
                         << QPainterPath::CurveToDataElement;
     }

◆ elementTypes()

QPainterPath::ElementType* QOutlineMapper::elementTypes ( ) const

inline

Definition at line 204 of file qoutlinemapper_p.h.

Referenced by endOutline().

204 { return m_element_types.size() == 0 ? 0 : m_element_types.data(); }

QDataBuffer::data

Type * data() const

Definition: qdatabuffer_p.h:84

QOutlineMapper::m_element_types

QDataBuffer< QPainterPath::ElementType > m_element_types

Definition: qoutlinemapper_p.h:207

QDataBuffer::size

int size() const

Definition: qdatabuffer_p.h:83

◆ endOutline()

void QOutlineMapper::endOutline ( )

Definition at line 168 of file qoutlinemapper.cpp.

Referenced by beginOutline(), convertPath(), and QRasterPaintEngine::drawPolygon().

 {
     closeSubpath();
 
     int element_count = m_elements.size();
 
     if (element_count == 0) {
         memset(&m_outline, 0, sizeof(m_outline));
         return;
     }
 
     QPointF *elements;
 
     // Transform the outline
     if (m_txop == QTransform::TxNone) {
         elements = m_elements.data();
     } else {
         if (m_txop == QTransform::TxTranslate) {
             for (int i=0; i<m_elements.size(); ++i) {
                 const QPointF &e = m_elements.at(i);
                 m_elements_dev << QPointF(e.x() + m_dx, e.y() + m_dy);
             }
         } else if (m_txop == QTransform::TxScale) {
             for (int i=0; i<m_elements.size(); ++i) {
                 const QPointF &e = m_elements.at(i);
                 m_elements_dev << QPointF(m_m11 * e.x() + m_dx, m_m22 * e.y() + m_dy);
             }
         } else if (m_txop < QTransform::TxProject) {
             for (int i=0; i<m_elements.size(); ++i) {
                 const QPointF &e = m_elements.at(i);
                 m_elements_dev << QPointF(m_m11 * e.x() + m_m21 * e.y() + m_dx,
                                           m_m22 * e.y() + m_m12 * e.x() + m_dy);
             }
         } else {
             const QVectorPath vp((qreal *)m_elements.data(), m_elements.size(), m_element_types.size() ? m_element_types.data() : 0);
             QPainterPath path = vp.convertToPainterPath();
             path = QTransform(m_m11, m_m12, m_m13, m_m21, m_m22, m_m23, m_dx, m_dy, m_m33).map(path);
             if (!(m_outline.flags & QT_FT_OUTLINE_EVEN_ODD_FILL))
                 path.setFillRule(Qt::WindingFill);
             uint old_txop = m_txop;
             m_txop = QTransform::TxNone;
             if (path.isEmpty())
                 m_valid = false;
             else
                 convertPath(path);
             m_txop = old_txop;
             return;
         }
         elements = m_elements_dev.data();
     }
 
     controlPointRect = boundingRect(elements, element_count);
 
 #ifdef QT_DEBUG_CONVERT
     printf(" - control point rect (%.2f, %.2f) %.2f x %.2f, clip=(%d,%d, %dx%d)\n",
            controlPointRect.x(), controlPointRect.y(),
            controlPointRect.width(), controlPointRect.height(),
            m_clip_rect.x(), m_clip_rect.y(), m_clip_rect.width(), m_clip_rect.height());
 #endif
 
 
     // Check for out of dev bounds...
     const bool do_clip = !m_in_clip_elements && ((controlPointRect.left() < -QT_RASTER_COORD_LIMIT
                           || controlPointRect.right() > QT_RASTER_COORD_LIMIT
                           || controlPointRect.top() < -QT_RASTER_COORD_LIMIT
                           || controlPointRect.bottom() > QT_RASTER_COORD_LIMIT
                           || controlPointRect.width() > QT_RASTER_COORD_LIMIT
                           || controlPointRect.height() > QT_RASTER_COORD_LIMIT));
 
     if (do_clip) {
         clipElements(elements, elementTypes(), element_count);
     } else {
         convertElements(elements, elementTypes(), element_count);
     }
 }

◆ lineTo()

void QOutlineMapper::lineTo ( const QPointF & pt )

inline

Definition at line 155 of file qoutlinemapper_p.h.

Referenced by closeSubpath(), convertPath(), and QRasterPaintEngine::drawPolygon().

                                           {
 #ifdef QT_DEBUG_CONVERT
         printf("QOutlineMapper::lineTo() (%f, %f)\n", pt.x(), pt.y());
 #endif
         m_elements.add(pt);
         m_element_types << QPainterPath::LineToElement;
     }

◆ moveTo()

void QOutlineMapper::moveTo ( const QPointF & pt )

inline

Definition at line 145 of file qoutlinemapper_p.h.

Referenced by convertPath(), and QRasterPaintEngine::drawPolygon().

                                           {
 #ifdef QT_DEBUG_CONVERT
         printf("QOutlineMapper::moveTo() (%f, %f)\n", pt.x(), pt.y());
 #endif
         closeSubpath();
         m_subpath_start = m_elements.size();
         m_elements << pt;
         m_element_types << QPainterPath::MoveToElement;
     }

◆ outline()

QT_FT_Outline* QOutlineMapper::outline ( )

inline

Definition at line 195 of file qoutlinemapper_p.h.

Referenced by convertPath(), and QRasterPaintEngine::drawPolygon().

                              {
         if (m_valid)
             return &m_outline;
         return 0;
     }

◆ setMatrix()

void QOutlineMapper::setMatrix ( const QTransform & m )

inline

Sets up the matrix to be used for conversion.

This also sets up the qt_path_iterator function that is used as a callback to get points.

Definition at line 107 of file qoutlinemapper_p.h.

     {
         m_m11 = m.m11();
         m_m12 = m.m12();
         m_m13 = m.m13();
         m_m21 = m.m21();
         m_m22 = m.m22();
         m_m23 = m.m23();
         m_m33 = m.m33();
         m_dx = m.dx();
         m_dy = m.dy();
         m_txop = m.type();
     }