painting/qpaintengine_raster.cpp

baseClip->setClipRect(deviceRect);

executed: }

Execution Count:14829

14829

1066

deviceRect = ~~clipRect~~deviceRectUnclipped;

executed (the execution status of this line is deduced): deviceRect = deviceRectUnclipped;

1067

executed (the execution status of this line is deduced): baseClip->setClipRect(deviceRect);

1068

exDeviceRect = deviceRect;

executed: }

Execution Count:13971

13971

1069 #ifdef QT_DEBUG_DRAW -

1070 qDebug() << "systemStateChanged" << this << "deviceRect" << deviceRect << ~~clipRect~~deviceRectUnclipped << systemClip; -

1071 #endif -

1072 -

1073

executed (the execution status of this line is deduced): exDeviceRect = deviceRect;

1074 -

1075

Q_Q(QRasterPaintEngine);

executed (the execution status of this line is deduced): QRasterPaintEngine * const q = q_func();

1076

if (q->state()) {

partially evaluated: q->state()

TRUE	FALSE
yes Evaluation Count:28800	no Evaluation Count:0

0-28800

1077

q->state()->strokeFlags |= QPaintEngine::DirtyClipRegion;

executed (the execution status of this line is deduced): q->state()->strokeFlags |= QPaintEngine::DirtyClipRegion;

1078

q->state()->fillFlags |= QPaintEngine::DirtyClipRegion;

executed (the execution status of this line is deduced): q->state()->fillFlags |= QPaintEngine::DirtyClipRegion;

1079

q->state()->pixmapFlags |= QPaintEngine::DirtyClipRegion;

executed (the execution status of this line is deduced): q->state()->pixmapFlags |= QPaintEngine::DirtyClipRegion;

1080

executed: }

Execution Count:28800

28800

1081

executed: }

Execution Count:28800

28800

1082 -

1083 void QRasterPaintEnginePrivate::updateMatrixData(QSpanData *spanData, const QBrush &b, const QTransform &m) -

1084 { -

1085 if (b.d->style == Qt::NoBrush || b.d->style == Qt::SolidPattern) -

1086 return; -

1087 -

1088 Q_Q(QRasterPaintEngine); -

1089 bool bilinear = q->state()->flags.bilinear; -

1090 -

1091 if (b.d->transform.type() > QTransform::TxNone) { // FALCON: optimize -

1092 spanData->setupMatrix(b.transform() * m, bilinear); -

1093 } else { -

1094 if (m.type() <= QTransform::TxTranslate) { -

1095 // specialize setupMatrix for translation matrices -

1096 // to avoid needless matrix inversion -

1097 spanData->m11 = 1; -

1098 spanData->m12 = 0; -

1099 spanData->m13 = 0; -

1100 spanData->m21 = 0; -

1101 spanData->m22 = 1; -

1102 spanData->m23 = 0; -

1103 spanData->m33 = 1; -

1104 spanData->dx = -m.dx(); -

1105 spanData->dy = -m.dy(); -

1106 spanData->txop = m.type(); -

1107 spanData->bilinear = bilinear; -

1108 spanData->fast_matrix = qAbs(m.dx()) < 1e4 && qAbs(m.dy()) < 1e4; -

1109 spanData->adjustSpanMethods(); -

1110 } else { -

1111 spanData->setupMatrix(m, bilinear); -

1112 } -

1113 } -

1114 } -

1115 -

1116 // #define QT_CLIPPING_RATIOS -

1117 -

1118 #ifdef QT_CLIPPING_RATIOS -

1119 int rectClips; -

1120 int regionClips; -

1121 int totalClips; -

1122 -

1123 static void checkClipRatios(QRasterPaintEnginePrivate *d) -

1124 { -

1125 if (d->clip()->hasRectClip) -

1126 rectClips++; -

1127 if (d->clip()->hasRegionClip) -

1128 regionClips++; -

1129 totalClips++; -

1130 -

1131 if ((totalClips % 5000) == 0) { -

1132 printf("Clipping ratio: rectangular=%f%%, region=%f%%, complex=%f%%\n", -

1133 rectClips * 100.0 / (qreal) totalClips, -

1134 regionClips * 100.0 / (qreal) totalClips, -

1135 (totalClips - rectClips - regionClips) * 100.0 / (qreal) totalClips); -

1136 totalClips = 0; -

1137 rectClips = 0; -

1138 regionClips = 0; -

1139 } -

1140 -

1141 } -

1142 #endif -

1143 -

1144 static void qrasterpaintengine_state_setNoClip(QRasterPaintEngineState *s) -

1145 { -

1146 if (s->flags.has_clip_ownership) -

1147 delete s->clip; -

1148 s->clip = 0; -

1149 s->flags.has_clip_ownership = false; -

1150 } -

1151 -

1152 static void qrasterpaintengine_dirty_clip(QRasterPaintEnginePrivate *d, QRasterPaintEngineState *s) -

1153 { -

1154 s->fillFlags |= QPaintEngine::DirtyClipPath; -

1155 s->strokeFlags |= QPaintEngine::DirtyClipPath; -

1156 s->pixmapFlags |= QPaintEngine::DirtyClipPath; -

1157 -

1158 d->solid_color_filler.clip = d->clip(); -

1159 d->solid_color_filler.adjustSpanMethods(); -

1160 -

1161 #ifdef QT_DEBUG_DRAW -

1162 dumpClip(d->rasterBuffer->width(), d->rasterBuffer->height(), &*d->clip()); -

1163 #endif -

1164 -

1165 } -

1166 -

1167 -

1168 /*! -

1169 \internal -

1170 */ -

1171 void QRasterPaintEngine::clip(const QVectorPath &path, Qt::ClipOperation op) -

1172 { -

1173 #ifdef QT_DEBUG_DRAW -

1174 qDebug() << "QRasterPaintEngine::clip(): " << path << op; -

1175 -

1176 if (path.elements()) { -

1177 for (int i=0; i<path.elementCount(); ++i) { -

1178 qDebug() << " - " << path.elements()[i] -

1179 << '(' << path.points()[i*2] << ", " << path.points()[i*2+1] << ')'; -

1180 } -

1181 } else { -

1182 for (int i=0; i<path.elementCount(); ++i) { -

1183 qDebug() << " ---- " -

1184 << '(' << path.points()[i*2] << ", " << path.points()[i*2+1] << ')'; -

1185 } -

1186 } -

1187 #endif -

1188 -

1189 Q_D(QRasterPaintEngine); -

1190 QRasterPaintEngineState *s = state(); -

1191 -

1192 const qreal *points = path.points(); -

1193 const QPainterPath::ElementType *types = path.elements(); -

1194 -

1195 // There are some cases that are not supported by clip(QRect) -

1196 if (op != Qt::IntersectClip || !s->clip || s->clip->hasRectClip || s->clip->hasRegionClip) { -

1197 if (s->matrix.type() <= QTransform::TxScale -

1198 && ((path.shape() == QVectorPath::RectangleHint) -

1199 || (isRect(points, path.elementCount()) -

1200 && (!types || (types[0] == QPainterPath::MoveToElement -

1201 && types[1] == QPainterPath::LineToElement -

1202 && types[2] == QPainterPath::LineToElement -

1203 && types[3] == QPainterPath::LineToElement))))) { -

1204 #ifdef QT_DEBUG_DRAW -

1205 qDebug() << " --- optimizing vector clip to rect clip..."; -

1206 #endif -

1207 -

1208 QRectF r(points[0], points[1], points[4]-points[0], points[5]-points[1]); -

1209 if (setClipRectInDeviceCoords(s->matrix.mapRect(r).toRect(), op)) -

1210 return; -

1211 } -

1212 } -

1213 -

1214 if (op == Qt::NoClip) { -

1215 qrasterpaintengine_state_setNoClip(s); -

1216 -

1217 } else { -

1218 QClipData *base = d->baseClip.data(); -

1219 -

1220 // Intersect with current clip when available... -

1221 if (op == Qt::IntersectClip && s->clip) -

1222 base = s->clip; -

1223 -

1224 // We always intersect, except when there is nothing to -

1225 // intersect with, in which case we simplify the operation to -

1226 // a replace... -

1227 Qt::ClipOperation isectOp = Qt::IntersectClip; -

1228 if (base == 0) -

1229 isectOp = Qt::ReplaceClip; -

1230 -

1231 QClipData *newClip = new QClipData(d->rasterBuffer->height()); -

1232 newClip->initialize(); -

1233 ClipData clipData = { base, newClip, isectOp }; -

1234 ensureOutlineMapper(); -

1235 d->rasterize(d->outlineMapper->convertPath(path), qt_span_clip, &clipData, 0); -

1236 -

1237 newClip->fixup(); -

1238 -

1239 if (s->flags.has_clip_ownership) -

1240 delete s->clip; -

1241 -

1242 s->clip = newClip; -

1243 s->flags.has_clip_ownership = true; -

1244 } -

1245 qrasterpaintengine_dirty_clip(d, s); -

1246 } -

1247 -

1248 -

1249 -

1250 /*! -

1251 \internal -

1252 */ -

1253 void QRasterPaintEngine::clip(const QRect &rect, Qt::ClipOperation op) -

1254 { -

1255 #ifdef QT_DEBUG_DRAW -

1256 qDebug() << "QRasterPaintEngine::clip(): " << rect << op; -

1257 #endif -

1258 -

1259 QRasterPaintEngineState *s = state(); -

1260 -

1261 if (op == Qt::NoClip) { -

1262 qrasterpaintengine_state_setNoClip(s); -

1263 -

1264 } else if (s->matrix.type() > QTransform::TxScale) { -

1265 QPaintEngineEx::clip(rect, op); -

1266 return; -

1267 -

1268 } else if (!setClipRectInDeviceCoords(s->matrix.mapRect(rect), op)) { -

1269 QPaintEngineEx::clip(rect, op); -

1270 return; -

1271 } -

1272 } -

1273 -

1274 -

1275 bool QRasterPaintEngine::setClipRectInDeviceCoords(const QRect &r, Qt::ClipOperation op) -

1276 { -

1277 Q_D(QRasterPaintEngine); -

1278 QRect clipRect = r & d->deviceRect; -

1279 QRasterPaintEngineState *s = state(); -

1280 -

1281 if (op == Qt::ReplaceClip || s->clip == 0) { -

1282 -

1283 // No current clip, hence we intersect with sysclip and be -

1284 // done with it... -

1285 QRegion clipRegion = systemClip(); -

1286 QClipData *clip = new QClipData(d->rasterBuffer->height()); -

1287 -

1288 if (clipRegion.isEmpty()) -

1289 clip->setClipRect(clipRect); -

1290 else -

1291 clip->setClipRegion(clipRegion & clipRect); -

1292 -

1293 if (s->flags.has_clip_ownership) -

1294 delete s->clip; -

1295 -

1296 s->clip = clip; -

1297 s->clip->enabled = true; -

1298 s->flags.has_clip_ownership = true; -

1299 -

1300 } else if (op == Qt::IntersectClip){ // intersect clip with current clip -

1301 QClipData *base = s->clip; -

1302 -

1303 Q_ASSERT(base); -

1304 if (base->hasRectClip || base->hasRegionClip) { -

1305 if (!s->flags.has_clip_ownership) { -

1306 s->clip = new QClipData(d->rasterBuffer->height()); -

1307 s->flags.has_clip_ownership = true; -

1308 } -

1309 if (base->hasRectClip) -

1310 s->clip->setClipRect(base->clipRect & clipRect); -

1311 else -

1312 s->clip->setClipRegion(base->clipRegion & clipRect); -

1313 s->clip->enabled = true; -

1314 } else { -

1315 return false; -

1316 } -

1317 } else { -

1318 return false; -

1319 } -

1320 -

1321 qrasterpaintengine_dirty_clip(d, s); -

1322 return true; -

1323 } -

1324 -

1325 -

1326 /*! -

1327 \internal -

1328 */ -

1329 void QRasterPaintEngine::clip(const QRegion &region, Qt::ClipOperation op) -

1330 { -

1331 #ifdef QT_DEBUG_DRAW -

1332 qDebug() << "QRasterPaintEngine::clip(): " << region << op; -

1333 #endif -

1334 -

1335 Q_D(QRasterPaintEngine); -

1336 -

1337 if (region.rectCount() == 1) { -

1338 clip(region.boundingRect(), op); -

1339 return; -

1340 } -

1341 -

1342 QRasterPaintEngineState *s = state(); -

1343 const QClipData *clip = d->clip(); -

1344 const QClipData *baseClip = d->baseClip.data(); -

1345 -

1346 if (op == Qt::NoClip) { -

1347 qrasterpaintengine_state_setNoClip(s); -

1348 } else if (s->matrix.type() > QTransform::TxScale -

1349 || (op == Qt::IntersectClip && !clip->hasRectClip && !clip->hasRegionClip) -

1350 || (op == Qt::ReplaceClip && !baseClip->hasRectClip && !baseClip->hasRegionClip)) { -

1351 QPaintEngineEx::clip(region, op); -

1352 } else { -

1353 const QClipData *curClip; -

1354 QClipData *newClip; -

1355 -

1356 if (op == Qt::IntersectClip) -

1357 curClip = clip; -

1358 else -

1359 curClip = baseClip; -

1360 -

1361 if (s->flags.has_clip_ownership) { -

1362 newClip = s->clip; -

1363 Q_ASSERT(newClip); -

1364 } else { -

1365 newClip = new QClipData(d->rasterBuffer->height()); -

1366 s->clip = newClip; -

1367 s->flags.has_clip_ownership = true; -

1368 } -

1369 -

1370 QRegion r = s->matrix.map(region); -

1371 if (curClip->hasRectClip) -

1372 newClip->setClipRegion(r & curClip->clipRect); -

1373 else if (curClip->hasRegionClip) -

1374 newClip->setClipRegion(r & curClip->clipRegion); -

1375 -

1376 qrasterpaintengine_dirty_clip(d, s); -

1377 } -

1378 } -

1379 -

1380 /*! -

1381 \fn const QClipData *QRasterPaintEngine::clipData() const -

1382 -

1383 \internal -

1384 */ -

1385 -

1386 -

1387 /*! -

1388 \internal -

1389 */ -

1390 void QRasterPaintEngine::fillPath(const QPainterPath &path, QSpanData *fillData) -

1391 { -

1392 #ifdef QT_DEBUG_DRAW -

1393 qDebug() << " --- fillPath, bounds=" << path.boundingRect(); -

1394 #endif -

1395 -

1396 if (!fillData->blend) -

1397 return; -

1398 -

1399 Q_D(QRasterPaintEngine); -

1400 -

1401 const QRectF controlPointRect = path.controlPointRect(); -

1402 -

1403 QRasterPaintEngineState *s = state(); -

1404 const QRect deviceRect = s->matrix.mapRect(controlPointRect).toRect(); -

1405 ProcessSpans blend = d->getBrushFunc(deviceRect, fillData); -

1406 const bool do_clip = (deviceRect.left() < -QT_RASTER_COORD_LIMIT -

1407 || deviceRect.right() > QT_RASTER_COORD_LIMIT -

1408 || deviceRect.top() < -QT_RASTER_COORD_LIMIT -

1409 || deviceRect.bottom() > QT_RASTER_COORD_LIMIT); -

1410 -

1411 if (!s->flags.antialiased && !do_clip) { -

1412 d->initializeRasterizer(fillData); -

1413 d->rasterizer->rasterize(path * s->matrix, path.fillRule()); -

1414 return; -

1415 } -

1416 -

1417 ensureOutlineMapper(); -

1418 d->rasterize(d->outlineMapper->convertPath(path), blend, fillData, d->rasterBuffer.data()); -

1419 } -

1420 -

1421 static void fillRect_normalized(const QRect &r, QSpanData *data, -

1422 QRasterPaintEnginePrivate *pe) -

1423 { -

1424 int x1, x2, y1, y2; -

1425 -

1426 bool rectClipped = true; -

1427 -

1428 if (data->clip) { -

1429 x1 = qMax(r.x(), data->clip->xmin); -

1430 x2 = qMin(r.x() + r.width(), data->clip->xmax); -

1431 y1 = qMax(r.y(), data->clip->ymin); -

1432 y2 = qMin(r.y() + r.height(), data->clip->ymax); -

1433 rectClipped = data->clip->hasRectClip; -

1434 -

1435 } else if (pe) { -

1436 x1 = qMax(r.x(), pe->deviceRect.x()); -

1437 x2 = qMin(r.x() + r.width(), pe->deviceRect.x() + pe->deviceRect.width()); -

1438 y1 = qMax(r.y(), pe->deviceRect.y()); -

1439 y2 = qMin(r.y() + r.height(), pe->deviceRect.y() + pe->deviceRect.height()); -

1440 } else { -

1441 x1 = qMax(r.x(), 0); -

1442 x2 = qMin(r.x() + r.width(), data->rasterBuffer->width()); -

1443 y1 = qMax(r.y(), 0); -

1444 y2 = qMin(r.y() + r.height(), data->rasterBuffer->height()); -

1445 } -

1446 -

1447 if (x2 <= x1 || y2 <= y1) -

1448 return; -

1449 -

1450 const int width = x2 - x1; -

1451 const int height = y2 - y1; -

1452 -

1453 bool isUnclipped = rectClipped -

1454 || (pe && pe->isUnclipped_normalized(QRect(x1, y1, width, height))); -

1455 -

1456 if (pe && isUnclipped) { -

1457 const QPainter::CompositionMode mode = pe->rasterBuffer->compositionMode; -

1458 -

1459 if (data->fillRect && (mode == QPainter::CompositionMode_Source -

1460 || (mode == QPainter::CompositionMode_SourceOver -

1461 && qAlpha(data->solid.color) == 255))) -

1462 { -

1463 data->fillRect(data->rasterBuffer, x1, y1, width, height, -

1464 data->solid.color); -

1465 return; -

1466 } -

1467 } -

1468 -

1469 ProcessSpans blend = isUnclipped ? data->unclipped_blend : data->blend; -

1470 -

1471 const int nspans = 256; -

1472 QT_FT_Span spans[nspans]; -

1473 -

1474 Q_ASSERT(data->blend); -

1475 int y = y1; -

1476 while (y < y2) { -

1477 int n = qMin(nspans, y2 - y); -

1478 int i = 0; -

1479 while (i < n) { -

1480 spans[i].x = x1; -

1481 spans[i].len = width; -

1482 spans[i].y = y + i; -

1483 spans[i].coverage = 255; -

1484 ++i; -

1485 } -

1486 -

1487 blend(n, spans, data); -

1488 y += n; -

1489 } -

1490 } -

1491 -

1492 /*! -

1493 \reimp -

1494 */ -

1495 void QRasterPaintEngine::drawRects(const QRect *rects, int rectCount) -

1496 { -

1497 #ifdef QT_DEBUG_DRAW -

1498 qDebug(" - QRasterPaintEngine::drawRect(), rectCount=%d", rectCount); -

1499 #endif -

1500

executed (the execution status of this line is deduced): QRasterPaintEnginePrivate * const d = d_func();

1501

ensureRasterState();

executed (the execution status of this line is deduced): ensureRasterState();

1502

executed (the execution status of this line is deduced): QRasterPaintEngineState *s = state();

1503 -

1504 // Fill -

1505

if (s->brushData.blend) {

executed (the execution status of this line is deduced): ensureBrush();

1506

evaluated: s->brushData.blend

TRUE	FALSE
yes Evaluation Count:6418	yes Evaluation Count:2013

2013-6418

1507

if (!s->flags.antialiased && s->matrix.type() <= QTransform::TxTranslate) {

evaluated: !s->flags.antialiased

TRUE	FALSE
yes Evaluation Count:6408	yes Evaluation Count:10

evaluated: s->matrix.type() <= QTransform::TxTranslate

TRUE	FALSE
yes Evaluation Count:6405	yes Evaluation Count:3

3-6408

1508

const QRect *r = rects;

executed (the execution status of this line is deduced): const QRect *r = rects;

1509

const QRect *lastRect = rects + rectCount;

executed (the execution status of this line is deduced): const QRect *lastRect = rects + rectCount;

1510 -

1511

int offset_x = int(s->matrix.dx());

executed (the execution status of this line is deduced): int offset_x = int(s->matrix.dx());

1512

int offset_y = int(s->matrix.dy());

executed (the execution status of this line is deduced): int offset_y = int(s->matrix.dy());

1513

while (r < lastRect) {

evaluated: r < lastRect

TRUE	FALSE
yes Evaluation Count:6405	yes Evaluation Count:6405

6405

1514

QRect rect = r->normalized();

executed (the execution status of this line is deduced): QRect rect = r->normalized();

1515

QRect rr = rect.translated(offset_x, offset_y);

executed (the execution status of this line is deduced): QRect rr = rect.translated(offset_x, offset_y);

1516

fillRect_normalized(rr, &s->brushData, d);

executed (the execution status of this line is deduced): fillRect_normalized(rr, &s->brushData, d);

1517

++r;

executed (the execution status of this line is deduced): ++r;

1518

executed: }

Execution Count:6405

6405

1519

for (int i=0; i<rectCount; ++i) {

executed: }

Execution Count:6405

6405

1520

QRectVectorPath path;

executed (the execution status of this line is deduced): QRectVectorPath path;

1521

evaluated: i<rectCount

TRUE	FALSE
yes Evaluation Count:13	yes Evaluation Count:13

1522

executed (the execution status of this line is deduced): path.set(rects[i]);

1523

fill(path, s->brush);

executed (the execution status of this line is deduced): fill(path, s->brush);

1524

executed: }

Execution Count:13

1525

executed: }

Execution Count:13

1526 } -

1527 -

1528

executed (the execution status of this line is deduced): ensurePen();

1529

evaluated: s->penData.blend

TRUE	FALSE
yes Evaluation Count:2384	yes Evaluation Count:6047

2384-6047

1530

QRectVectorPath path;

executed (the execution status of this line is deduced): QRectVectorPath path;

1531

QCosmeticStroker stroker(s, d->deviceRect, d->deviceRectUnclipped);

evaluated: s->flags.fast_pen

TRUE	FALSE
yes Evaluation Count:2378	yes Evaluation Count:6

6-2378

1532

executed (the execution status of this line is deduced): QCosmeticStroker stroker(s, d->deviceRect, d->deviceRectUnclipped);

1533

stroker.setLegacyRoundingEnabled(s->flags.legacy_rounding);

executed (the execution status of this line is deduced): stroker.setLegacyRoundingEnabled(s->flags.legacy_rounding);

1534

evaluated: i < rectCount

TRUE	FALSE
yes Evaluation Count:2378	yes Evaluation Count:2378

2378

1535

executed (the execution status of this line is deduced): path.set(rects[i]);

1536

stroker.drawPath(path);

executed (the execution status of this line is deduced): stroker.drawPath(path);

1537

executed: }

Execution Count:2378

2378

1538

executed: }

Execution Count:2378

2378

1539

evaluated: i < rectCount

TRUE	FALSE
yes Evaluation Count:6	yes Evaluation Count:6

1540

executed (the execution status of this line is deduced): path.set(rects[i]);

1541

stroke(path, s->pen);

executed (the execution status of this line is deduced): stroke(path, s->pen);

1542

executed: }

Execution Count:6

1543

executed: }

Execution Count:6

1544 } -

1545

executed: }

Execution Count:8431

8431

1546 -

1547 /*! -

1548 \reimp -

1549 */ -

1550 void QRasterPaintEngine::drawRects(const QRectF *rects, int rectCount) -

1551 { -

1552 #ifdef QT_DEBUG_DRAW -

1553 qDebug(" - QRasterPaintEngine::drawRect(QRectF*), rectCount=%d", rectCount); -

1554 #endif -

1555 #ifdef QT_FAST_SPANS -

1556

executed (the execution status of this line is deduced): QRasterPaintEnginePrivate * const d = d_func();

1557

ensureRasterState();

executed (the execution status of this line is deduced): ensureRasterState();

1558

if (s->flags.tx_noshear) {

executed (the execution status of this line is deduced): QRasterPaintEngineState *s = state();

1559 -

1560 -

1561

evaluated: s->flags.tx_noshear

TRUE	FALSE
yes Evaluation Count:616	yes Evaluation Count:8

8-616

1562

if (s->brushData.blend) {

executed (the execution status of this line is deduced): ensureBrush();

1563

evaluated: s->brushData.blend

TRUE	FALSE
yes Evaluation Count:313	yes Evaluation Count:303

303-313

1564

d->initializeRasterizer(&s->brushData);

executed (the execution status of this line is deduced): d->initializeRasterizer(&s->brushData);

1565

const QRectF &rect = rects[i].normalized();

evaluated: i < rectCount

TRUE	FALSE
yes Evaluation Count:313	yes Evaluation Count:313

313

1566

executed (the execution status of this line is deduced): const QRectF &rect = rects[i].normalized();

1567

if (rect.isEmpty())

evaluated: rect.isEmpty()

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:311

2-311

1568

continue;

executed: continue;

Execution Count:2

1569

const QPointF a = s->matrix.map((rect.topLeft() + rect.bottomLeft()) * 0.5f);

executed (the execution status of this line is deduced): const QPointF a = s->matrix.map((rect.topLeft() + rect.bottomLeft()) * 0.5f);

1570

const QPointF b = s->matrix.map((rect.topRight() + rect.bottomRight()) * 0.5f);

executed (the execution status of this line is deduced): const QPointF b = s->matrix.map((rect.topRight() + rect.bottomRight()) * 0.5f);

1571

d->rasterizer->rasterizeLine(a, b, rect.height() / rect.width());

executed (the execution status of this line is deduced): d->rasterizer->rasterizeLine(a, b, rect.height() / rect.width());

1572

executed: }

Execution Count:311

311

1573

executed: }

Execution Count:313

313

1574 -

1575

executed (the execution status of this line is deduced): ensurePen();

1576

evaluated: s->penData.blend

TRUE	FALSE
yes Evaluation Count:361	yes Evaluation Count:255

255-361

1577

QRectVectorPath path;

executed (the execution status of this line is deduced): QRectVectorPath path;

1578

QCosmeticStroker stroker(s, d->deviceRect, d->deviceRectUnclipped);

evaluated: s->flags.fast_pen

TRUE	FALSE
yes Evaluation Count:337	yes Evaluation Count:24

24-337

1579

executed (the execution status of this line is deduced): QCosmeticStroker stroker(s, d->deviceRect, d->deviceRectUnclipped);

1580

stroker.setLegacyRoundingEnabled(s->flags.legacy_rounding);

executed (the execution status of this line is deduced): stroker.setLegacyRoundingEnabled(s->flags.legacy_rounding);

1581

evaluated: i < rectCount

TRUE	FALSE
yes Evaluation Count:337	yes Evaluation Count:337

337

1582

executed (the execution status of this line is deduced): path.set(rects[i]);

1583

stroker.drawPath(path);

executed (the execution status of this line is deduced): stroker.drawPath(path);

1584

executed: }

Execution Count:337

337

1585

executed: }

Execution Count:337

337

1586

evaluated: i < rectCount

TRUE	FALSE
yes Evaluation Count:24	yes Evaluation Count:24

1587

QPaintEngineEx::stroke(path, s->lastPen);

executed (the execution status of this line is deduced): path.set(rects[i]);

1588

executed (the execution status of this line is deduced): QPaintEngineEx::stroke(path, s->lastPen);

1589

executed: }

Execution Count:24

1590

executed: }

Execution Count:24

1591 } -

1592 -

1593

QPaintEngineEx::drawRects(rects, rectCount);

executed: return;

Execution Count:616

616

1594 } -

1595 #endif // QT_FAST_SPANS -

1596

executed (the execution status of this line is deduced): QPaintEngineEx::drawRects(rects, rectCount);

1597

executed: }

Execution Count:8

1598 -

1599 -

1600 /*! -

1601 \internal -

1602 */ -

1603 void QRasterPaintEngine::stroke(const QVectorPath &path, const QPen &pen) -

1604 { -

1605

executed (the execution status of this line is deduced): QRasterPaintEnginePrivate * const d = d_func();

1606

executed (the execution status of this line is deduced): QRasterPaintEngineState *s = state();

1607 -

1608

ensurePen(pen);

executed (the execution status of this line is deduced): ensurePen(pen);

1609

evaluated: !s->penData.blend

TRUE	FALSE
yes Evaluation Count:13	yes Evaluation Count:13272

13-13272

1610

executed: return;

Execution Count:13

1611 -

1612

QCosmeticStroker stroker(s, d->deviceRect, d->deviceRectUnclipped);

evaluated: s->flags.fast_pen

TRUE	FALSE
yes Evaluation Count:11507	yes Evaluation Count:1765

1765-11507

1613

executed (the execution status of this line is deduced): QCosmeticStroker stroker(s, d->deviceRect, d->deviceRectUnclipped);

1614

stroker.setLegacyRoundingEnabled(s->flags.legacy_rounding);

executed (the execution status of this line is deduced): stroker.setLegacyRoundingEnabled(s->flags.legacy_rounding);

1615

stroker.drawPath(path);

executed (the execution status of this line is deduced): stroker.drawPath(path);

1616

} else if (s->flags.non_complex_pen && path.shape() == QVectorPath::LinesHint) {

executed: }

Execution Count:11507

evaluated: s->flags.non_complex_pen

TRUE	FALSE
yes Evaluation Count:1545	yes Evaluation Count:220

evaluated: path.shape() == QVectorPath::LinesHint

TRUE	FALSE
yes Evaluation Count:875	yes Evaluation Count:670

220-11507

1617

qreal width = qt_pen_is_cosmetic(s->lastPen, s->renderHints)

partially evaluated: qt_pen_is_cosmetic(s->lastPen, s->renderHints)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:875

0-875

1618

? (qpen_widthf(s->lastPen) == 0 ? 1 : qpen_widthf(s->lastPen))

executed (the execution status of this line is deduced): ? (qpen_widthf(s->lastPen) == 0 ? 1 : qpen_widthf(s->lastPen))

1619

: qpen_widthf(s->lastPen) * s->txscale;

executed (the execution status of this line is deduced): : qpen_widthf(s->lastPen) * s->txscale;

1620

int dashIndex = 0;

executed (the execution status of this line is deduced): int dashIndex = 0;

1621

qreal dashOffset = s->lastPen.dashOffset();

executed (the execution status of this line is deduced): qreal dashOffset = s->lastPen.dashOffset();

1622

bool inDash = true;

executed (the execution status of this line is deduced): bool inDash = true;

1623

qreal patternLength = 0;

executed (the execution status of this line is deduced): qreal patternLength = 0;

1624

const QVector<qreal> pattern = s->lastPen.dashPattern();

executed (the execution status of this line is deduced): const QVector<qreal> pattern = s->lastPen.dashPattern();

1625

for (int i = 0; i < pattern.size(); ++i)

evaluated: i < pattern.size()

TRUE	FALSE
yes Evaluation Count:6	yes Evaluation Count:875

6-875

1626

patternLength += pattern.at(i);

executed: patternLength += pattern.at(i);

Execution Count:6

1627 -

1628

if (patternLength > 0) {

evaluated: patternLength > 0

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:874

1-874

1629

int n = qFloor(dashOffset / patternLength);

executed (the execution status of this line is deduced): int n = qFloor(dashOffset / patternLength);

1630

dashOffset -= n * patternLength;

executed (the execution status of this line is deduced): dashOffset -= n * patternLength;

1631

while (dashOffset >= pattern.at(dashIndex)) {

partially evaluated: dashOffset >= pattern.at(dashIndex)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:1

0-1

1632

dashOffset -= pattern.at(dashIndex);

never executed (the execution status of this line is deduced): dashOffset -= pattern.at(dashIndex);

1633

if (++dashIndex >= pattern.size())

never evaluated: ++dashIndex >= pattern.size()

1634

dashIndex = 0;

never executed: dashIndex = 0;

1635

inDash = !inDash;

never executed (the execution status of this line is deduced): inDash = !inDash;

never executed: }

executed: }

Execution Count:1

1638 -

1639

d->initializeRasterizer(&s->penData);

executed (the execution status of this line is deduced): QRasterPaintEnginePrivate * const d = d_func();

1640

executed (the execution status of this line is deduced): d->initializeRasterizer(&s->penData);

1641

int lineCount = path.elementCount() / 2;

executed (the execution status of this line is deduced): int lineCount = path.elementCount() / 2;

1642

const QLineF *lines = reinterpret_cast<const QLineF *>(path.points());

executed (the execution status of this line is deduced): const QLineF *lines = reinterpret_cast<const QLineF *>(path.points());

1643 -

1644

for (int i = 0; i < lineCount; ++i) {

evaluated: i < lineCount

TRUE	FALSE
yes Evaluation Count:876	yes Evaluation Count:875

875-876

1645

if (lines[i].p1() == lines[i].p2()) {

evaluated: lines[i].p1() == lines[i].p2()

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:875

1-875

1646

if (s->lastPen.capStyle() != Qt::FlatCap) {

partially evaluated: s->lastPen.capStyle() != Qt::FlatCap

TRUE	FALSE
yes Evaluation Count:1	no Evaluation Count:0

0-1

1647

QPointF p = lines[i].p1();

executed (the execution status of this line is deduced): QPointF p = lines[i].p1();

1648

QLineF line = s->matrix.map(QLineF(QPointF(p.x() - width*0.5, p.y()),

executed (the execution status of this line is deduced): QLineF line = s->matrix.map(QLineF(QPointF(p.x() - width*0.5, p.y()),

1649

QPointF(p.x() + width*0.5, p.y())));

executed (the execution status of this line is deduced): QPointF(p.x() + width*0.5, p.y())));

1650

d->rasterizer->rasterizeLine(line.p1(), line.p2(), 1);

executed (the execution status of this line is deduced): d->rasterizer->rasterizeLine(line.p1(), line.p2(), 1);

1651

const QLineF line = s->matrix.map(lines[i]);

executed: }

Execution Count:1

1652

continue;

executed: continue;

Execution Count:1

1653 } -

1654 -

1655

executed (the execution status of this line is deduced): const QLineF line = s->matrix.map(lines[i]);

1656

if (qpen_style(s->lastPen) == Qt::SolidLine) {

evaluated: qpen_style(s->lastPen) == Qt::SolidLine

TRUE	FALSE
yes Evaluation Count:872	yes Evaluation Count:3

3-872

1657

d->rasterizer->rasterizeLine(line.p1(), line.p2(),

executed (the execution status of this line is deduced): d->rasterizer->rasterizeLine(line.p1(), line.p2(),

1658

width / line.length(),

executed (the execution status of this line is deduced): width / line.length(),

1659

s->lastPen.capStyle() == Qt::SquareCap);

executed (the execution status of this line is deduced): s->lastPen.capStyle() == Qt::SquareCap);

1660

d->rasterizeLine_dashed(line, width,

executed: }

Execution Count:872

872

1661

executed (the execution status of this line is deduced): d->rasterizeLine_dashed(line, width,

1662

&dashIndex, &dashOffset, &inDash);

executed (the execution status of this line is deduced): &dashIndex, &dashOffset, &inDash);

1663

executed: }

Execution Count:3

1664 } -

1665

QPaintEngineEx::stroke(path, pen);

executed: }

Execution Count:875

875

1666 else -

1667

executed: QPaintEngineEx::stroke(path, pen);

Execution Count:890

890

1668 } -

1669 -

1670 QRect QRasterPaintEngine::toNormalizedFillRect(const QRectF &rect) -

1671 { -

1672 QRasterPaintEngineState *s = state(); -

1673 -

1674 qreal delta = s->flags.legacy_rounding ? aliasedCoordinateDelta : qreal(0); -

1675 -

1676 int x1 = qRound(rect.x() + delta); -

1677 int y1 = qRound(rect.y() + delta); -

1678 int x2 = qRound(rect.right() + delta); -

1679 int y2 = qRound(rect.bottom() + delta); -

1680 -

1681 if (x2 < x1) -

1682 qSwap(x1, x2); -

1683 if (y2 < y1) -

1684 qSwap(y1, y2); -

1685 -

1686 return QRect(x1, y1, x2 - x1, y2 - y1); -

1687 } -

1688 -

1689 /*! -

1690 \internal -

1691 */ -

1692 void QRasterPaintEngine::fill(const QVectorPath &path, const QBrush &brush) -

1693 { -

1694 if (path.isEmpty()) -

1695 return; -

1696 #ifdef QT_DEBUG_DRAW -

1697 QRectF rf = path.controlPointRect(); -

1698 qDebug() << "QRasterPaintEngine::fill(): " -

1699 << "size=" << path.elementCount() -

1700 << ", hints=" << hex << path.hints() -

1701 << rf << brush; -

1702 #endif -

1703 -

1704 Q_D(QRasterPaintEngine); -

1705 QRasterPaintEngineState *s = state(); -

1706 -

1707 ensureBrush(brush); -

1708 if (!s->brushData.blend) -

1709 return; -

1710 -

1711 if (path.shape() == QVectorPath::RectangleHint) { -

1712 if (!s->flags.antialiased && s->matrix.type() <= QTransform::TxScale) { -

1713 const qreal *p = path.points(); -

1714 QPointF tl = QPointF(p[0], p[1]) * s->matrix; -

1715 QPointF br = QPointF(p[4], p[5]) * s->matrix; -

1716 fillRect_normalized(toNormalizedFillRect(QRectF(tl, br)), &s->brushData, d); -

1717 return; -

1718 } -

1719 ensureRasterState(); -

1720 if (s->flags.tx_noshear) { -

1721 d->initializeRasterizer(&s->brushData); -

1722 // ### Is normalizing really necessary here? -

1723 const qreal *p = path.points(); -

1724 QRectF r = QRectF(p[0], p[1], p[2] - p[0], p[7] - p[1]).normalized(); -

1725 if (!r.isEmpty()) { -

1726 const QPointF a = s->matrix.map((r.topLeft() + r.bottomLeft()) * 0.5f); -

1727 const QPointF b = s->matrix.map((r.topRight() + r.bottomRight()) * 0.5f); -

1728 d->rasterizer->rasterizeLine(a, b, r.height() / r.width()); -

1729 } -

1730 return; -

1731 } -

1732 } -

1733 -

1734 // ### Optimize for non transformed ellipses and rectangles... -

1735 QRectF cpRect = path.controlPointRect(); -

1736 const QRect deviceRect = s->matrix.mapRect(cpRect).toRect(); -

1737 ProcessSpans blend = d->getBrushFunc(deviceRect, &s->brushData); -

1738 -

1739 // ### Falcon -

1740 // const bool do_clip = (deviceRect.left() < -QT_RASTER_COORD_LIMIT -

1741 // || deviceRect.right() > QT_RASTER_COORD_LIMIT -

1742 // || deviceRect.top() < -QT_RASTER_COORD_LIMIT -

1743 // || deviceRect.bottom() > QT_RASTER_COORD_LIMIT); -

1744 -

1745 // ### Falonc: implement.... -

1746 // if (!s->flags.antialiased && !do_clip) { -

1747 // d->initializeRasterizer(&s->brushData); -

1748 // d->rasterizer->rasterize(path * d->matrix, path.fillRule()); -

1749 // return; -

1750 // } -

1751 -

1752 ensureOutlineMapper(); -

1753 d->rasterize(d->outlineMapper->convertPath(path), blend, &s->brushData, d->rasterBuffer.data()); -

1754 } -

1755 -

1756 void QRasterPaintEngine::fillRect(const QRectF &r, QSpanData *data) -

1757 { -

1758 Q_D(QRasterPaintEngine); -

1759 QRasterPaintEngineState *s = state(); -

1760 -

1761 if (!s->flags.antialiased) { -

1762 uint txop = s->matrix.type(); -

1763 if (txop == QTransform::TxNone) { -

1764 fillRect_normalized(toNormalizedFillRect(r), data, d); -

1765 return; -

1766 } else if (txop == QTransform::TxTranslate) { -

1767 const QRect rr = toNormalizedFillRect(r.translated(s->matrix.dx(), s->matrix.dy())); -

1768 fillRect_normalized(rr, data, d); -

1769 return; -

1770 } else if (txop == QTransform::TxScale) { -

1771 const QRect rr = toNormalizedFillRect(s->matrix.mapRect(r)); -

1772 fillRect_normalized(rr, data, d); -

1773 return; -

1774 } -

1775 } -

1776 ensureRasterState(); -

1777 if (s->flags.tx_noshear) { -

1778 d->initializeRasterizer(data); -

1779 QRectF nr = r.normalized(); -

1780 if (!nr.isEmpty()) { -

1781 const QPointF a = s->matrix.map((nr.topLeft() + nr.bottomLeft()) * 0.5f); -

1782 const QPointF b = s->matrix.map((nr.topRight() + nr.bottomRight()) * 0.5f); -

1783 d->rasterizer->rasterizeLine(a, b, nr.height() / nr.width()); -

1784 } -

1785 return; -

1786 } -

1787 -

1788 QPainterPath path; -

1789 path.addRect(r); -

1790 ensureOutlineMapper(); -

1791 fillPath(path, data); -

1792 } -

1793 -

1794 /*! -

1795 \reimp -

1796 */ -

1797 void QRasterPaintEngine::fillRect(const QRectF &r, const QBrush &brush) -

1798 { -

1799 #ifdef QT_DEBUG_DRAW -

1800 qDebug() << "QRasterPaintEngine::fillRecct(): " << r << brush; -

1801 #endif -

1802 QRasterPaintEngineState *s = state(); -

1803 -

1804 ensureBrush(brush); -

1805 if (!s->brushData.blend) -

1806 return; -

1807 -

1808 fillRect(r, &s->brushData); -

1809 } -

1810 -

1811 /*! -

1812 \reimp -

1813 */ -

1814 void QRasterPaintEngine::fillRect(const QRectF &r, const QColor &color) -

1815 { -

1816 #ifdef QT_DEBUG_DRAW -

1817 qDebug() << "QRasterPaintEngine::fillRect(): " << r << color; -

1818 #endif -

1819 Q_D(QRasterPaintEngine); -

1820 QRasterPaintEngineState *s = state(); -

1821 -

1822 d->solid_color_filler.solid.color = PREMUL(ARGB_COMBINE_ALPHA(color.rgba(), s->intOpacity)); -

1823 if ((d->solid_color_filler.solid.color & 0xff000000) == 0 -

1824 && s->composition_mode == QPainter::CompositionMode_SourceOver) { -

1825 return; -

1826 } -

1827 d->solid_color_filler.clip = d->clip(); -

1828 d->solid_color_filler.adjustSpanMethods(); -

1829 fillRect(r, &d->solid_color_filler); -

1830 } -

1831 -

1832 static inline bool isAbove(const QPointF *a, const QPointF *b) -

1833 { -

1834 return a->y() < b->y(); -

1835 } -

1836 -

1837 static bool splitPolygon(const QPointF *points, int pointCount, QVector<QPointF> *upper, QVector<QPointF> *lower) -

1838 { -

1839 Q_ASSERT(upper); -

1840 Q_ASSERT(lower); -

1841 -

1842 Q_ASSERT(pointCount >= 2); -

1843 -

1844 QVector<const QPointF *> sorted; -

1845 sorted.reserve(pointCount); -

1846 -

1847 upper->reserve(pointCount * 3 / 4); -

1848 lower->reserve(pointCount * 3 / 4); -

1849 -

1850 for (int i = 0; i < pointCount; ++i) -

1851 sorted << points + i; -

1852 -

1853 qSort(sorted.begin(), sorted.end(), isAbove); -

1854 -

1855 qreal splitY = sorted.at(sorted.size() / 2)->y(); -

1856 -

1857 const QPointF *end = points + pointCount; -

1858 const QPointF *last = end - 1; -

1859 -

1860 QVector<QPointF> *bin[2] = { upper, lower }; -

1861 -

1862 for (const QPointF *p = points; p < end; ++p) { -

1863 int side = p->y() < splitY; -

1864 int lastSide = last->y() < splitY; -

1865 -

1866 if (side != lastSide) { -

1867 if (qFuzzyCompare(p->y(), splitY)) { -

1868 bin[!side]->append(*p); -

1869 } else if (qFuzzyCompare(last->y(), splitY)) { -

1870 bin[side]->append(*last); -

1871 } else { -

1872 QPointF delta = *p - *last; -

1873 QPointF intersection(p->x() + delta.x() * (splitY - p->y()) / delta.y(), splitY); -

1874 -

1875 bin[0]->append(intersection); -

1876 bin[1]->append(intersection); -

1877 } -

1878 } -

1879 -

1880 bin[side]->append(*p); -

1881 -

1882 last = p; -

1883 } -

1884 -

1885 // give up if we couldn't reduce the point count -

1886 return upper->size() < pointCount && lower->size() < pointCount; -

1887 } -

1888 -

1889 /*! -

1890 \internal -

1891 */ -

1892 void QRasterPaintEngine::fillPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode) -

1893 { -

1894 Q_D(QRasterPaintEngine); -

1895 QRasterPaintEngineState *s = state(); -

1896 -

1897 const int maxPoints = 0xffff; -

1898 -

1899 // max amount of points that raster engine can reliably handle -

1900 if (pointCount > maxPoints) { -

1901 QVector<QPointF> upper, lower; -

1902 -

1903 if (splitPolygon(points, pointCount, &upper, &lower)) { -

1904 fillPolygon(upper.constData(), upper.size(), mode); -

1905 fillPolygon(lower.constData(), lower.size(), mode); -

1906 } else -

1907 qWarning("Polygon too complex for filling."); -

1908 -

1909 return; -

1910 } -

1911 -

1912 // Compose polygon fill.., -

1913 QVectorPath vp((qreal *) points, pointCount, 0, QVectorPath::polygonFlags(mode)); -

1914 ensureOutlineMapper(); -

1915 QT_FT_Outline *outline = d->outlineMapper->convertPath(vp); -

1916 -

1917 // scanconvert. -

1918 ProcessSpans brushBlend = d->getBrushFunc(d->outlineMapper->controlPointRect, -

1919 &s->brushData); -

1920 d->rasterize(outline, brushBlend, &s->brushData, d->rasterBuffer.data()); -

1921 } -

1922 -

1923 /*! -

1924 \reimp -

1925 */ -

1926 void QRasterPaintEngine::drawPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode) -

1927 { -

1928

executed (the execution status of this line is deduced): QRasterPaintEnginePrivate * const d = d_func();

1929

Q_ASSERT(pointCount >= 2);

executed (the execution status of this line is deduced): QRasterPaintEngineState *s = state();

1930 -

1931 #ifdef QT_DEBUG_DRAW -

1932 qDebug(" - QRasterPaintEngine::drawPolygon(F), pointCount=%d", pointCount); -

1933 for (int i=0; i<pointCount; ++i) -

1934 qDebug() << " - " << points[i]; -

1935 #endif -

1936

executed (the execution status of this line is deduced): qt_noop();

1937 -

1938

if (mode != PolylineMode && isRect((qreal *) points, pointCount)) {

partially evaluated: mode != PolylineMode

TRUE	FALSE
yes Evaluation Count:447	no Evaluation Count:0

evaluated: isRect((qreal *) points, pointCount)

TRUE	FALSE
yes Evaluation Count:20	yes Evaluation Count:427

0-447

1939

QRectF r(points[0], points[2]);

executed (the execution status of this line is deduced): QRectF r(points[0], points[2]);

1940

drawRects(&r, 1);

executed (the execution status of this line is deduced): drawRects(&r, 1);

1941

executed: return;

Execution Count:20

1942 } -

1943 -

1944

if (mode != PolylineMode) {

executed (the execution status of this line is deduced): ensurePen();

1945

partially evaluated: mode != PolylineMode

TRUE	FALSE
yes Evaluation Count:427	no Evaluation Count:0

0-427

1946 // Do the fill... -

1947

fillPolygon(points, pointCount, mode);

executed (the execution status of this line is deduced): ensureBrush();

1948

if (s->brushData.blend)

evaluated: s->brushData.blend

TRUE	FALSE
yes Evaluation Count:391	yes Evaluation Count:36

36-391

1949

executed: fillPolygon(points, pointCount, mode);

Execution Count:391

391

1950

executed: }

Execution Count:427

427

1951 -

1952 // Do the outline... -

1953

QVectorPath vp((qreal *) points, pointCount, 0, QVectorPath::polygonFlags(mode));

evaluated: s->penData.blend

TRUE	FALSE
yes Evaluation Count:408	yes Evaluation Count:19

19-408

1954

executed (the execution status of this line is deduced): QVectorPath vp((qreal *) points, pointCount, 0, QVectorPath::polygonFlags(mode));

1955

QCosmeticStroker stroker(s, d->deviceRect, d->deviceRectUnclipped);

evaluated: s->flags.fast_pen

TRUE	FALSE
yes Evaluation Count:396	yes Evaluation Count:12

12-396

1956

executed (the execution status of this line is deduced): QCosmeticStroker stroker(s, d->deviceRect, d->deviceRectUnclipped);

1957

stroker.setLegacyRoundingEnabled(s->flags.legacy_rounding);

executed (the execution status of this line is deduced): stroker.setLegacyRoundingEnabled(s->flags.legacy_rounding);

1958

stroker.drawPath(vp);

executed (the execution status of this line is deduced): stroker.drawPath(vp);

1959

QPaintEngineEx::stroke(vp, s->lastPen);

executed: }

Execution Count:396

396

1960

executed (the execution status of this line is deduced): QPaintEngineEx::stroke(vp, s->lastPen);

1961

executed: }

Execution Count:12

1962 } -

1963

executed: }

Execution Count:427

427

1964 -

1965 /*! -

1966 \reimp -

1967 */ -

1968 void QRasterPaintEngine::drawPolygon(const QPoint *points, int pointCount, PolygonDrawMode mode) -

1969 { -

1970

executed (the execution status of this line is deduced): QRasterPaintEnginePrivate * const d = d_func();

1971

Q_ASSERT(pointCount >= 2);

executed (the execution status of this line is deduced): QRasterPaintEngineState *s = state();

1972 -

1973 #ifdef QT_DEBUG_DRAW -

1974 qDebug(" - QRasterPaintEngine::drawPolygon(I), pointCount=%d", pointCount); -

1975 for (int i=0; i<pointCount; ++i) -

1976 qDebug() << " - " << points[i]; -

1977 #endif -

1978

executed (the execution status of this line is deduced): qt_noop();

1979

if (mode != PolylineMode && isRect((int *) points, pointCount)) {

evaluated: mode != PolylineMode

TRUE	FALSE
yes Evaluation Count:906	yes Evaluation Count:50052

evaluated: isRect((int *) points, pointCount)

TRUE	FALSE
yes Evaluation Count:20	yes Evaluation Count:886

20-50052

1980

QRect r(points[0].x(),

executed (the execution status of this line is deduced): QRect r(points[0].x(),

1981

points[0].y(),

executed (the execution status of this line is deduced): points[0].y(),

1982

points[2].x() - points[0].x(),

executed (the execution status of this line is deduced): points[2].x() - points[0].x(),

1983

points[2].y() - points[0].y());

executed (the execution status of this line is deduced): points[2].y() - points[0].y());

1984

drawRects(&r, 1);

executed (the execution status of this line is deduced): drawRects(&r, 1);

1985

executed: return;

Execution Count:20

1986 } -

1987 -

1988

if (mode != PolylineMode) {

executed (the execution status of this line is deduced): ensurePen();

1989 -

1990 // Do the fill -

1991

evaluated: mode != PolylineMode

TRUE	FALSE
yes Evaluation Count:886	yes Evaluation Count:50052

886-50052

1992

if (s->brushData.blend) {

executed (the execution status of this line is deduced): ensureBrush();

1993

evaluated: s->brushData.blend

TRUE	FALSE
yes Evaluation Count:850	yes Evaluation Count:36

36-850

1994 // Compose polygon fill.., -

1995

ensureOutlineMapper();

executed (the execution status of this line is deduced): ensureOutlineMapper();

1996

d->outlineMapper->beginOutline(mode == WindingMode ? Qt::WindingFill : Qt::OddEvenFill);

executed (the execution status of this line is deduced): d->outlineMapper->beginOutline(mode == WindingMode ? Qt::WindingFill : Qt::OddEvenFill);

1997

d->outlineMapper->moveTo(*points);

executed (the execution status of this line is deduced): d->outlineMapper->moveTo(*points);

1998

const QPoint *p = points;

executed (the execution status of this line is deduced): const QPoint *p = points;

1999

const QPoint *ep = points + pointCount - 1;

executed (the execution status of this line is deduced): const QPoint *ep = points + pointCount - 1;

2000 do { -

2001

d->outlineMapper->lineTo(*(++p));

executed (the execution status of this line is deduced): d->outlineMapper->lineTo(*(++p));

2002

} while (p < ep);

executed: }

Execution Count:2317

evaluated: p < ep

TRUE	FALSE
yes Evaluation Count:1467	yes Evaluation Count:850

850-2317

2003

d->outlineMapper->endOutline();

executed (the execution status of this line is deduced): d->outlineMapper->endOutline();

2004 -

2005 // scanconvert. -

2006

ProcessSpans brushBlend = d->getBrushFunc(d->outlineMapper->controlPointRect,

executed (the execution status of this line is deduced): ProcessSpans brushBlend = d->getBrushFunc(d->outlineMapper->controlPointRect,

2007

&s->brushData);

executed (the execution status of this line is deduced): &s->brushData);

2008

d->rasterize(d->outlineMapper->outline(), brushBlend, &s->brushData, d->rasterBuffer.data());

executed (the execution status of this line is deduced): d->rasterize(d->outlineMapper->outline(), brushBlend, &s->brushData, d->rasterBuffer.data());

2009

executed: }

Execution Count:850

850

2010

executed: }

Execution Count:886

886

2011 -

2012 // Do the outline... -

2013

int count = pointCount * 2;

evaluated: s->penData.blend

TRUE	FALSE
yes Evaluation Count:50920	yes Evaluation Count:18

18-50920

2014

executed (the execution status of this line is deduced): int count = pointCount * 2;

2015

QVarLengthArray<qreal> fpoints(count);

executed (the execution status of this line is deduced): QVarLengthArray<qreal> fpoints(count);

2016

for (int i=0; i<count; ++i)

evaluated: i<count

TRUE	FALSE
yes Evaluation Count:309350	yes Evaluation Count:50920

50920-309350

2017

fpoints[i] = ((int *) points)[i];

executed: fpoints[i] = ((int *) points)[i];

Execution Count:309350

309350

2018

QVectorPath vp((qreal *) fpoints.data(), pointCount, 0, QVectorPath::polygonFlags(mode));

executed (the execution status of this line is deduced): QVectorPath vp((qreal *) fpoints.data(), pointCount, 0, QVectorPath::polygonFlags(mode));

2019 -

2020

QCosmeticStroker stroker(s, d->deviceRect, d->deviceRectUnclipped);

evaluated: s->flags.fast_pen

TRUE	FALSE
yes Evaluation Count:50908	yes Evaluation Count:12

12-50908

2021

executed (the execution status of this line is deduced): QCosmeticStroker stroker(s, d->deviceRect, d->deviceRectUnclipped);

2022

stroker.setLegacyRoundingEnabled(s->flags.legacy_rounding);

executed (the execution status of this line is deduced): stroker.setLegacyRoundingEnabled(s->flags.legacy_rounding);

2023

stroker.drawPath(vp);

executed (the execution status of this line is deduced): stroker.drawPath(vp);

2024

QPaintEngineEx::stroke(vp, s->lastPen);

executed: }

Execution Count:50908

50908

2025

executed (the execution status of this line is deduced): QPaintEngineEx::stroke(vp, s->lastPen);

2026

executed: }

Execution Count:12

2027 } -

2028

executed: }

Execution Count:50938

50938

2029 -

2030 /*! -

2031 \internal -

2032 */ -

2033 void QRasterPaintEngine::drawPixmap(const QPointF &pos, const QPixmap &pixmap) -

2034 { -

2035 #ifdef QT_DEBUG_DRAW -

2036 qDebug() << " - QRasterPaintEngine::drawPixmap(), pos=" << pos << " pixmap=" << pixmap.size() << "depth=" << pixmap.depth(); -

2037 #endif -

2038 -

2039 QPlatformPixmap *pd = pixmap.handle(); -

2040 if (pd->classId() == QPlatformPixmap::RasterClass) { -

2041 const QImage &image = static_cast<QRasterPlatformPixmap *>(pd)->image; -

2042 if (image.depth() == 1) { -

2043 Q_D(QRasterPaintEngine); -

2044 QRasterPaintEngineState *s = state(); -

2045 if (s->matrix.type() <= QTransform::TxTranslate) { -

2046 ensurePen(); -

2047 drawBitmap(pos + QPointF(s->matrix.dx(), s->matrix.dy()), image, &s->penData); -

2048 } else { -

2049 drawImage(pos, d->rasterBuffer->colorizeBitmap(image, s->pen.color())); -

2050 } -

2051 } else { -

2052 QRasterPaintEngine::drawImage(pos, image); -

2053 } -

2054 } else { -

2055 const QImage image = pixmap.toImage(); -

2056 if (pixmap.depth() == 1) { -

2057 Q_D(QRasterPaintEngine); -

2058 QRasterPaintEngineState *s = state(); -

2059 if (s->matrix.type() <= QTransform::TxTranslate) { -

2060 ensurePen(); -

2061 drawBitmap(pos + QPointF(s->matrix.dx(), s->matrix.dy()), image, &s->penData); -

2062 } else { -

2063 drawImage(pos, d->rasterBuffer->colorizeBitmap(image, s->pen.color())); -

2064 } -

2065 } else { -

2066 QRasterPaintEngine::drawImage(pos, image); -

2067 } -

2068 } -

2069 } -

2070 -

2071 /*! -

2072 \reimp -

2073 */ -

2074 void QRasterPaintEngine::drawPixmap(const QRectF &r, const QPixmap &pixmap, const QRectF &sr) -

2075 { -

2076 #ifdef QT_DEBUG_DRAW -

2077 qDebug() << " - QRasterPaintEngine::drawPixmap(), r=" << r << " sr=" << sr << " pixmap=" << pixmap.size() << "depth=" << pixmap.depth(); -

2078 #endif -

2079 -

2080 QPlatformPixmap* pd = pixmap.handle(); -

2081 if (pd->classId() == QPlatformPixmap::RasterClass) { -

2082 const QImage &image = static_cast<QRasterPlatformPixmap *>(pd)->image; -

2083 if (image.depth() == 1) { -

2084 Q_D(QRasterPaintEngine); -

2085 QRasterPaintEngineState *s = state(); -

2086 if (s->matrix.type() <= QTransform::TxTranslate -

2087 && r.size() == sr.size() -

2088 && r.size() == pixmap.size()) { -

2089 ensurePen(); -

2090 drawBitmap(r.topLeft() + QPointF(s->matrix.dx(), s->matrix.dy()), image, &s->penData); -

2091 return; -

2092 } else { -

2093 drawImage(r, d->rasterBuffer->colorizeBitmap(image, s->pen.color()), sr); -

2094 } -

2095 } else { -

2096 drawImage(r, image, sr); -

2097 } -

2098 } else { -

2099 QRect clippedSource = sr.toAlignedRect().intersected(pixmap.rect()); -

2100 const QImage image = pd->toImage(clippedSource); -

2101 QRectF translatedSource = sr.translated(-clippedSource.topLeft()); -

2102 if (image.depth() == 1) { -

2103 Q_D(QRasterPaintEngine); -

2104 QRasterPaintEngineState *s = state(); -

2105 if (s->matrix.type() <= QTransform::TxTranslate -

2106 && r.size() == sr.size() -

2107 && r.size() == pixmap.size()) { -

2108 ensurePen(); -

2109 drawBitmap(r.topLeft() + QPointF(s->matrix.dx(), s->matrix.dy()), image, &s->penData); -

2110 return; -

2111 } else { -

2112 drawImage(r, d->rasterBuffer->colorizeBitmap(image, s->pen.color()), translatedSource); -

2113 } -

2114 } else { -

2115 drawImage(r, image, translatedSource); -

2116 } -

2117 } -

2118 } -

2119 -

2120 static inline int fast_ceil_positive(const qreal &v) -

2121 { -

2122 const int iv = int(v); -

2123 if (v - iv == 0) -

2124 return iv; -

2125 else -

2126 return iv + 1; -

2127 } -

2128 -

2129 static inline const QRect toAlignedRect_positive(const QRectF &rect) -

2130 { -

2131 const int xmin = int(rect.x()); -

2132 const int xmax = int(fast_ceil_positive(rect.right())); -

2133 const int ymin = int(rect.y()); -

2134 const int ymax = int(fast_ceil_positive(rect.bottom())); -

2135 return QRect(xmin, ymin, xmax - xmin, ymax - ymin); -

2136 } -

2137 -

2138 /*! -

2139 \internal -

2140 */ -

2141 void QRasterPaintEngine::drawImage(const QPointF &p, const QImage &img) -

2142 { -

2143 #ifdef QT_DEBUG_DRAW -

2144 qDebug() << " - QRasterPaintEngine::drawImage(), p=" << p << " image=" << img.size() << "depth=" << img.depth(); -

2145 #endif -

2146 -

2147 Q_D(QRasterPaintEngine); -

2148 QRasterPaintEngineState *s = state(); -

2149 qreal scale = img.devicePixelRatio(); -

2150 -

2151 if (scale > 1.0 || s->matrix.type() > QTransform::TxTranslate) { -

2152 drawImage(QRectF(p.x(), p.y(), img.width() / scale, img.height() / scale), -

2153 img, -

2154 QRectF(0, 0, img.width(), img.height())); -

2155 } else { -

2156 -

2157 const QClipData *clip = d->clip(); -

2158 QPointF pt(p.x() + s->matrix.dx(), p.y() + s->matrix.dy()); -

2159 -

2160 if (d->canUseFastImageBlending(d->rasterBuffer->compositionMode, img)) { -

2161 SrcOverBlendFunc func = qBlendFunctions[d->rasterBuffer->format][img.format()]; -

2162 if (func) { -

2163 if (!clip) { -

2164 d->drawImage(pt, img, func, d->deviceRect, s->intOpacity); -

2165 return; -

2166 } else if (clip->hasRectClip) { -

2167 d->drawImage(pt, img, func, clip->clipRect, s->intOpacity); -

2168 return; -

2169 } -

2170 } -

2171 } -

2172 -

2173 -

2174 -

2175 d->image_filler.clip = clip; -

2176 d->image_filler.initTexture(&img, s->intOpacity, QTextureData::Plain, img.rect()); -

2177 if (!d->image_filler.blend) -

2178 return; -

2179 d->image_filler.dx = -pt.x(); -

2180 d->image_filler.dy = -pt.y(); -

2181 QRect rr = img.rect().translated(qRound(pt.x()), qRound(pt.y())); -

2182 -

2183 fillRect_normalized(rr, &d->image_filler, d); -

2184 } -

2185 -

2186 } -

2187 -

2188 QRectF qt_mapRect_non_normalizing(const QRectF &r, const QTransform &t) -

2189 { -

2190 return QRectF(r.topLeft() * t, r.bottomRight() * t); -

2191 } -

2192 -

2193 namespace { -

2194 enum RotationType { -

2195 Rotation90, -

2196 Rotation180, -

2197 Rotation270, -

2198 NoRotation -

2199 }; -

2200 -

2201 inline RotationType qRotationType(const QTransform &transform) -

2202 { -

2203 QTransform::TransformationType type = transform.type(); -

2204 -

2205 if (type > QTransform::TxRotate) -

2206 return NoRotation; -

2207 -

2208 if (type == QTransform::TxRotate && qFuzzyIsNull(transform.m11()) && qFuzzyCompare(transform.m12(), qreal(-1)) -

2209 && qFuzzyCompare(transform.m21(), qreal(1)) && qFuzzyIsNull(transform.m22())) -

2210 return Rotation90; -

2211 -

2212 if (type == QTransform::TxScale && qFuzzyCompare(transform.m11(), qreal(-1)) && qFuzzyIsNull(transform.m12()) -

2213 && qFuzzyIsNull(transform.m21()) && qFuzzyCompare(transform.m22(), qreal(-1))) -

2214 return Rotation180; -

2215 -

2216 if (type == QTransform::TxRotate && qFuzzyIsNull(transform.m11()) && qFuzzyCompare(transform.m12(), qreal(1)) -

2217 && qFuzzyCompare(transform.m21(), qreal(-1)) && qFuzzyIsNull(transform.m22())) -

2218 return Rotation270; -

2219 -

2220 return NoRotation; -

2221 } -

2222 -

2223 inline bool isPixelAligned(const QRectF &rect) { -

2224 return QRectF(rect.toRect()) == rect; -

2225 } -

2226 } -

2227 -

2228 /*! -

2229 \reimp -

2230 */ -

2231 void QRasterPaintEngine::drawImage(const QRectF &r, const QImage &img, const QRectF &sr, -

2232 Qt::ImageConversionFlags) -

2233 { -

2234 #ifdef QT_DEBUG_DRAW -

2235 qDebug() << " - QRasterPaintEngine::drawImage(), r=" << r << " sr=" << sr << " image=" << img.size() << "depth=" << img.depth(); -

2236 #endif -

2237 -

2238 if (r.isEmpty()) -

2239 return; -

2240 -

2241 Q_D(QRasterPaintEngine); -

2242 QRasterPaintEngineState *s = state(); -

2243 int sr_l = qFloor(sr.left()); -

2244 int sr_r = qCeil(sr.right()) - 1; -

2245 int sr_t = qFloor(sr.top()); -

2246 int sr_b = qCeil(sr.bottom()) - 1; -

2247 -

2248 if (s->matrix.type() <= QTransform::TxScale && !s->flags.antialiased && sr_l == sr_r && sr_t == sr_b) { -

2249 // as fillRect will apply the aliased coordinate delta we need to -

2250 // subtract it here as we don't use it for image drawing -

2251 QTransform old = s->matrix; -

2252 -

2253 if (s->flags.legacy_rounding) -

2254 s->matrix = s->matrix * QTransform::fromTranslate(-aliasedCoordinateDelta, -aliasedCoordinateDelta); -

2255 -

2256 // Do whatever fillRect() does, but without premultiplying the color if it's already premultiplied. -

2257 QRgb color = img.pixel(sr_l, sr_t); -

2258 switch (img.format()) { -

2259 case QImage::Format_ARGB32_Premultiplied: -

2260 case QImage::Format_ARGB8565_Premultiplied: -

2261 case QImage::Format_ARGB6666_Premultiplied: -

2262 case QImage::Format_ARGB8555_Premultiplied: -

2263 case QImage::Format_ARGB4444_Premultiplied: -

2264 // Combine premultiplied color with the opacity set on the painter. -

2265 d->solid_color_filler.solid.color = -

2266 ((((color & 0x00ff00ff) * s->intOpacity) >> 8) & 0x00ff00ff) -

2267 | ((((color & 0xff00ff00) >> 8) * s->intOpacity) & 0xff00ff00); -

2268 break; -

2269 default: -

2270 d->solid_color_filler.solid.color = PREMUL(ARGB_COMBINE_ALPHA(color, s->intOpacity)); -

2271 break; -

2272 } -

2273 -

2274 if ((d->solid_color_filler.solid.color & 0xff000000) == 0 -

2275 && s->composition_mode == QPainter::CompositionMode_SourceOver) { -

2276 return; -

2277 } -

2278 -

2279 d->solid_color_filler.clip = d->clip(); -

2280 d->solid_color_filler.adjustSpanMethods(); -

2281 fillRect(r, &d->solid_color_filler); -

2282 -

2283 s->matrix = old; -

2284 return; -

2285 } -

2286 -

2287 bool stretch_sr = r.width() != sr.width() || r.height() != sr.height(); -

2288 -

2289 const QClipData *clip = d->clip(); -

2290 -

2291 if (s->matrix.type() > QTransform::TxTranslate -

2292 && !stretch_sr -

2293 && (!clip || clip->hasRectClip) -

2294 && s->intOpacity == 256 -

2295 && (d->rasterBuffer->compositionMode == QPainter::CompositionMode_SourceOver -

2296 || d->rasterBuffer->compositionMode == QPainter::CompositionMode_Source) -

2297 && d->rasterBuffer->format == img.format() -

2298 && (d->rasterBuffer->format == QImage::Format_RGB16 -

2299 || d->rasterBuffer->format == QImage::Format_RGB32 -

2300 || (d->rasterBuffer->format == QImage::Format_ARGB32_Premultiplied -

2301 && d->rasterBuffer->compositionMode == QPainter::CompositionMode_Source))) -

2302 { -

2303 RotationType rotationType = qRotationType(s->matrix); -

2304 -

2305 if (rotationType != NoRotation && qMemRotateFunctions[d->rasterBuffer->format][rotationType] && img.rect().contains(sr.toAlignedRect())) { -

2306 QRectF transformedTargetRect = s->matrix.mapRect(r); -

2307 -

2308 if ((!(s->renderHints & QPainter::SmoothPixmapTransform) && !(s->renderHints & QPainter::Antialiasing)) -

2309 || (isPixelAligned(transformedTargetRect) && isPixelAligned(sr))) -

2310 { -

2311 QRect clippedTransformedTargetRect = transformedTargetRect.toRect().intersected(clip ? clip->clipRect : d->deviceRect); -

2312 if (clippedTransformedTargetRect.isNull()) -

2313 return; -

2314 -

2315 QRectF clippedTargetRect = s->matrix.inverted().mapRect(QRectF(clippedTransformedTargetRect)); -

2316 -

2317 QRect clippedSourceRect -

2318 = QRectF(sr.x() + clippedTargetRect.x() - r.x(), sr.y() + clippedTargetRect.y() - r.y(), -

2319 clippedTargetRect.width(), clippedTargetRect.height()).toRect(); -

2320 -

2321 uint dbpl = d->rasterBuffer->bytesPerLine(); -

2322 uint sbpl = img.bytesPerLine(); -

2323 -

2324 uchar *dst = d->rasterBuffer->buffer(); -

2325 uint bpp = img.depth() >> 3; -

2326 -

2327 const uchar *srcBase = img.bits() + clippedSourceRect.y() * sbpl + clippedSourceRect.x() * bpp; -

2328 uchar *dstBase = dst + clippedTransformedTargetRect.y() * dbpl + clippedTransformedTargetRect.x() * bpp; -

2329 -

2330 uint cw = clippedSourceRect.width(); -

2331 uint ch = clippedSourceRect.height(); -

2332 -

2333 qMemRotateFunctions[d->rasterBuffer->format][rotationType](srcBase, cw, ch, sbpl, dstBase, dbpl); -

2334 -

2335 return; -

2336 } -

2337 } -

2338 } -

2339 -

2340 if (s->matrix.type() > QTransform::TxTranslate || stretch_sr) { -

2341 -

2342 QRectF targetBounds = s->matrix.mapRect(r); -

2343 bool exceedsPrecision = targetBounds.width() > 0xffff -

2344 || targetBounds.height() > 0xffff; -

2345 -

2346 if (!exceedsPrecision && d->canUseFastImageBlending(d->rasterBuffer->compositionMode, img)) { -

2347 if (s->matrix.type() > QTransform::TxScale) { -

2348 SrcOverTransformFunc func = qTransformFunctions[d->rasterBuffer->format][img.format()]; -

2349 if (func && (!clip || clip->hasRectClip)) { -

2350 func(d->rasterBuffer->buffer(), d->rasterBuffer->bytesPerLine(), img.bits(), -

2351 img.bytesPerLine(), r, sr, !clip ? d->deviceRect : clip->clipRect, -

2352 s->matrix, s->intOpacity); -

2353 return; -

2354 } -

2355 } else { -

2356 // Test for optimized high-dpi case: 2x source on 2x target. (Could be generalized to nX.) -

2357 bool sourceRect2x = r.width() * 2 == sr.width() && r.height() * 2 == sr.height(); -

2358 bool scale2x = (s->matrix.m11() == qreal(2)) && (s->matrix.m22() == qreal(2)); -

2359 if (s->matrix.type() == QTransform::TxScale && sourceRect2x && scale2x) { -

2360 SrcOverBlendFunc func = qBlendFunctions[d->rasterBuffer->format][img.format()]; -

2361 if (func) { -

2362 QPointF pt(r.x() * 2 + s->matrix.dx(), r.y() * 2 + s->matrix.dy()); -

2363 if (!clip) { -

2364 d->drawImage(pt, img, func, d->deviceRect, s->intOpacity, sr.toRect()); -

2365 return; -

2366 } else if (clip->hasRectClip) { -

2367 d->drawImage(pt, img, func, clip->clipRect, s->intOpacity, sr.toRect()); -

2368 return; -

2369 } -

2370 } -

2371 } -

2372 SrcOverScaleFunc func = qScaleFunctions[d->rasterBuffer->format][img.format()]; -

2373 if (func && (!clip || clip->hasRectClip)) { -

2374 func(d->rasterBuffer->buffer(), d->rasterBuffer->bytesPerLine(), -

2375 img.bits(), img.bytesPerLine(), -

2376 qt_mapRect_non_normalizing(r, s->matrix), sr, -

2377 !clip ? d->deviceRect : clip->clipRect, -

2378 s->intOpacity); -

2379 return; -

2380 } -

2381 } -

2382 } -

2383 -

2384 QTransform copy = s->matrix; -

2385 copy.translate(r.x(), r.y()); -

2386 if (stretch_sr) -

2387 copy.scale(r.width() / sr.width(), r.height() / sr.height()); -

2388 copy.translate(-sr.x(), -sr.y()); -

2389 -

2390 d->image_filler_xform.clip = clip; -

2391 d->image_filler_xform.initTexture(&img, s->intOpacity, QTextureData::Plain, toAlignedRect_positive(sr)); -

2392 if (!d->image_filler_xform.blend) -

2393 return; -

2394 d->image_filler_xform.setupMatrix(copy, s->flags.bilinear); -

2395 -

2396 if (!s->flags.antialiased && s->matrix.type() == QTransform::TxScale) { -

2397 QRectF rr = s->matrix.mapRect(r); -

2398 -

2399 const int x1 = qRound(rr.x()); -

2400 const int y1 = qRound(rr.y()); -

2401 const int x2 = qRound(rr.right()); -

2402 const int y2 = qRound(rr.bottom()); -

2403 -

2404 fillRect_normalized(QRect(x1, y1, x2-x1, y2-y1), &d->image_filler_xform, d); -

2405 return; -

2406 } -

2407 -

2408 #ifdef QT_FAST_SPANS -

2409 ensureRasterState(); -

2410 if (s->flags.tx_noshear || s->matrix.type() == QTransform::TxScale) { -

2411 d->initializeRasterizer(&d->image_filler_xform); -

2412 d->rasterizer->setAntialiased(s->flags.antialiased); -

2413 d->rasterizer->setLegacyRoundingEnabled(s->flags.legacy_rounding); -

2414 -

2415 const QPointF offs = s->flags.legacy_rounding ? QPointF(aliasedCoordinateDelta, aliasedCoordinateDelta) : QPointF(); -

2416 -

2417 const QRectF &rect = r.normalized(); -

2418 const QPointF a = s->matrix.map((rect.topLeft() + rect.bottomLeft()) * 0.5f) - offs; -

2419 const QPointF b = s->matrix.map((rect.topRight() + rect.bottomRight()) * 0.5f) - offs; -

2420 -

2421 if (s->flags.tx_noshear) -

2422 d->rasterizer->rasterizeLine(a, b, rect.height() / rect.width()); -

2423 else -

2424 d->rasterizer->rasterizeLine(a, b, qAbs((s->matrix.m22() * rect.height()) / (s->matrix.m11() * rect.width()))); -

2425 return; -

2426 } -

2427 #endif -

2428 const qreal offs = s->flags.legacy_rounding ? aliasedCoordinateDelta : qreal(0); -

2429 QPainterPath path; -

2430 path.addRect(r); -

2431 QTransform m = s->matrix; -

2432 s->matrix = QTransform(m.m11(), m.m12(), m.m13(), -

2433 m.m21(), m.m22(), m.m23(), -

2434 m.m31() - offs, m.m32() - offs, m.m33()); -

2435 fillPath(path, &d->image_filler_xform); -

2436 s->matrix = m; -

2437 } else { -

2438 if (d->canUseFastImageBlending(d->rasterBuffer->compositionMode, img)) { -

2439 SrcOverBlendFunc func = qBlendFunctions[d->rasterBuffer->format][img.format()]; -

2440 if (func) { -

2441 QPointF pt(r.x() + s->matrix.dx(), r.y() + s->matrix.dy()); -

2442 if (!clip) { -

2443 d->drawImage(pt, img, func, d->deviceRect, s->intOpacity, sr.toRect()); -

2444 return; -

2445 } else if (clip->hasRectClip) { -

2446 d->drawImage(pt, img, func, clip->clipRect, s->intOpacity, sr.toRect()); -

2447 return; -

2448 } -

2449 } -

2450 } -

2451 -

2452 d->image_filler.clip = clip; -

2453 d->image_filler.initTexture(&img, s->intOpacity, QTextureData::Plain, toAlignedRect_positive(sr)); -

2454 if (!d->image_filler.blend) -

2455 return; -

2456 d->image_filler.dx = -(r.x() + s->matrix.dx()) + sr.x(); -

2457 d->image_filler.dy = -(r.y() + s->matrix.dy()) + sr.y(); -

2458 -

2459 QRectF rr = r; -

2460 rr.translate(s->matrix.dx(), s->matrix.dy()); -

2461 -

2462 const int x1 = qRound(rr.x()); -

2463 const int y1 = qRound(rr.y()); -

2464 const int x2 = qRound(rr.right()); -

2465 const int y2 = qRound(rr.bottom()); -

2466 -

2467 fillRect_normalized(QRect(x1, y1, x2-x1, y2-y1), &d->image_filler, d); -

2468 } -

2469 } -

2470 -

2471 /*! -

2472 \reimp -

2473 */ -

2474 void QRasterPaintEngine::drawTiledPixmap(const QRectF &r, const QPixmap &pixmap, const QPointF &sr) -

2475 { -

2476 #ifdef QT_DEBUG_DRAW -

2477 qDebug() << " - QRasterPaintEngine::drawTiledPixmap(), r=" << r << "pixmap=" << pixmap.size(); -

2478 #endif -

2479 Q_D(QRasterPaintEngine); -

2480 QRasterPaintEngineState *s = state(); -

2481 -

2482 QImage image; -

2483 -

2484 QPlatformPixmap *pd = pixmap.handle(); -

2485 if (pd->classId() == QPlatformPixmap::RasterClass) { -

2486 image = static_cast<QRasterPlatformPixmap *>(pd)->image; -

2487 } else { -

2488 image = pixmap.toImage(); -

2489 } -

2490 -

2491 if (image.depth() == 1) -

2492 image = d->rasterBuffer->colorizeBitmap(image, s->pen.color()); -

2493 -

2494 if (s->matrix.type() > QTransform::TxTranslate) { -

2495 QTransform copy = s->matrix; -

2496 copy.translate(r.x(), r.y()); -

2497 copy.translate(-sr.x(), -sr.y()); -

2498 d->image_filler_xform.clip = d->clip(); -

2499 d->image_filler_xform.initTexture(&image, s->intOpacity, QTextureData::Tiled); -

2500 if (!d->image_filler_xform.blend) -

2501 return; -

2502 d->image_filler_xform.setupMatrix(copy, s->flags.bilinear); -

2503 -

2504 #ifdef QT_FAST_SPANS -

2505 ensureRasterState(); -

2506 if (s->flags.tx_noshear || s->matrix.type() == QTransform::TxScale) { -

2507 d->initializeRasterizer(&d->image_filler_xform); -

2508 d->rasterizer->setAntialiased(s->flags.antialiased); -

2509 d->rasterizer->setLegacyRoundingEnabled(s->flags.legacy_rounding); -

2510 -

2511 const QRectF &rect = r.normalized(); -

2512 const QPointF a = s->matrix.map((rect.topLeft() + rect.bottomLeft()) * 0.5f); -

2513 const QPointF b = s->matrix.map((rect.topRight() + rect.bottomRight()) * 0.5f); -

2514 if (s->flags.tx_noshear) -

2515 d->rasterizer->rasterizeLine(a, b, rect.height() / rect.width()); -

2516 else -

2517 d->rasterizer->rasterizeLine(a, b, qAbs((s->matrix.m22() * rect.height()) / (s->matrix.m11() * rect.width()))); -

2518 return; -

2519 } -

2520 #endif -

2521 QPainterPath path; -

2522 path.addRect(r); -

2523 fillPath(path, &d->image_filler_xform); -

2524 } else { -

2525 d->image_filler.clip = d->clip(); -

2526 -

2527 d->image_filler.initTexture(&image, s->intOpacity, QTextureData::Tiled); -

2528 if (!d->image_filler.blend) -

2529 return; -

2530 d->image_filler.dx = -(r.x() + s->matrix.dx()) + sr.x(); -

2531 d->image_filler.dy = -(r.y() + s->matrix.dy()) + sr.y(); -

2532 -

2533 QRectF rr = r; -

2534 rr.translate(s->matrix.dx(), s->matrix.dy()); -

2535 fillRect_normalized(rr.toRect().normalized(), &d->image_filler, d); -

2536 } -

2537 } -

2538 -

2539 -

2540 //QWS hack -

2541 static inline bool monoVal(const uchar* s, int x) -

2542 { -

2543 return (s[x>>3] << (x&7)) & 0x80; -

2544 } -

2545 -

2546 /*! -

2547 \internal -

2548 */ -

2549 QRasterBuffer *QRasterPaintEngine::rasterBuffer() -

2550 { -

2551 Q_D(QRasterPaintEngine); -

2552 return d->rasterBuffer.data(); -

2553 } -

2554 -

2555 /*! -

2556 \internal -

2557 */ -

2558 void QRasterPaintEngine::alphaPenBlt(const void* src, int bpl, int depth, int rx,int ry,int w,int h) -

2559 { -

2560 Q_D(QRasterPaintEngine); -

2561 QRasterPaintEngineState *s = state(); -

2562 -

2563 if (!s->penData.blend) -

2564 return; -

2565 -

2566 QRasterBuffer *rb = d->rasterBuffer.data(); -

2567 -

2568 const QRect rect(rx, ry, w, h); -

2569 const QClipData *clip = d->clip(); -

2570 bool unclipped = false; -

2571 if (clip) { -

2572 // inlined QRect::intersects -

2573 const bool intersects = qMax(clip->xmin, rect.left()) <= qMin(clip->xmax - 1, rect.right()) -

2574 && qMax(clip->ymin, rect.top()) <= qMin(clip->ymax - 1, rect.bottom()); -

2575 -

2576 if (clip->hasRectClip) { -

2577 unclipped = rx > clip->xmin -

2578 && rx + w < clip->xmax -

2579 && ry > clip->ymin -

2580 && ry + h < clip->ymax; -

2581 } -

2582 -

2583 if (!intersects) -

2584 return; -

2585 } else { -

2586 // inlined QRect::intersects -

2587 const bool intersects = qMax(0, rect.left()) <= qMin(rb->width() - 1, rect.right()) -

2588 && qMax(0, rect.top()) <= qMin(rb->height() - 1, rect.bottom()); -

2589 if (!intersects) -

2590 return; -

2591 -

2592 // inlined QRect::contains -

2593 const bool contains = rect.left() >= 0 && rect.right() < rb->width() -

2594 && rect.top() >= 0 && rect.bottom() < rb->height(); -

2595 -

2596 unclipped = contains && d->isUnclipped_normalized(rect); -

2597 } -

2598 -

2599 ProcessSpans blend = unclipped ? s->penData.unclipped_blend : s->penData.blend; -

2600 const uchar * scanline = static_cast<const uchar *>(src); -

2601 -

2602 if (s->flags.fast_text) { -

2603 if (unclipped) { -

2604 if (depth == 1) { -

2605 if (s->penData.bitmapBlit) { -

2606 s->penData.bitmapBlit(rb, rx, ry, s->penData.solid.color, -

2607 scanline, w, h, bpl); -

2608 return; -

2609 } -

2610 } else if (depth == 8) { -

2611 if (s->penData.alphamapBlit) { -

2612 s->penData.alphamapBlit(rb, rx, ry, s->penData.solid.color, -

2613 scanline, w, h, bpl, 0); -

2614 return; -

2615 } -

2616 } else if (depth == 32) { -

2617 // (A)RGB Alpha mask where the alpha component is not used. -

2618 if (s->penData.alphaRGBBlit) { -

2619 s->penData.alphaRGBBlit(rb, rx, ry, s->penData.solid.color, -

2620 (const uint *) scanline, w, h, bpl / 4, 0); -

2621 return; -

2622 } -

2623 } -

2624 } else if (d->deviceDepth == 32 && (depth == 8 || depth == 32)) { -

2625 // (A)RGB Alpha mask where the alpha component is not used. -

2626 if (!clip) { -

2627 int nx = qMax(0, rx); -

2628 int ny = qMax(0, ry); -

2629 -

2630 // Move scanline pointer to compensate for moved x and y -

2631 int xdiff = nx - rx; -

2632 int ydiff = ny - ry; -

2633 scanline += ydiff * bpl; -

2634 scanline += xdiff * (depth == 32 ? 4 : 1); -

2635 -

2636 w -= xdiff; -

2637 h -= ydiff; -

2638 -

2639 if (nx + w > d->rasterBuffer->width()) -

2640 w = d->rasterBuffer->width() - nx; -

2641 if (ny + h > d->rasterBuffer->height()) -

2642 h = d->rasterBuffer->height() - ny; -

2643 -

2644 rx = nx; -

2645 ry = ny; -

2646 } -

2647 if (depth == 8 && s->penData.alphamapBlit) { -

2648 s->penData.alphamapBlit(rb, rx, ry, s->penData.solid.color, -

2649 scanline, w, h, bpl, clip); -

2650 } else if (depth == 32 && s->penData.alphaRGBBlit) { -

2651 s->penData.alphaRGBBlit(rb, rx, ry, s->penData.solid.color, -

2652 (const uint *) scanline, w, h, bpl / 4, clip); -

2653 } -

2654 return; -

2655 } -

2656 } -

2657 -

2658 int x0 = 0; -

2659 if (rx < 0) { -

2660 x0 = -rx; -

2661 w -= x0; -

2662 } -

2663 -

2664 int y0 = 0; -

2665 if (ry < 0) { -

2666 y0 = -ry; -

2667 scanline += bpl * y0; -

2668 h -= y0; -

2669 } -

2670 -

2671 w = qMin(w, rb->width() - qMax(0, rx)); -

2672 h = qMin(h, rb->height() - qMax(0, ry)); -

2673 -

2674 if (w <= 0 || h <= 0) -

2675 return; -

2676 -

2677 const int NSPANS = 256; -

2678 QSpan spans[NSPANS]; -

2679 int current = 0; -

2680 -

2681 const int x1 = x0 + w; -

2682 const int y1 = y0 + h; -

2683 -

2684 if (depth == 1) { -

2685 for (int y = y0; y < y1; ++y) { -

2686 for (int x = x0; x < x1; ) { -

2687 if (!monoVal(scanline, x)) { -

2688 ++x; -

2689 continue; -

2690 } -

2691 -

2692 if (current == NSPANS) { -

2693 blend(current, spans, &s->penData); -

2694 current = 0; -

2695 } -

2696 spans[current].x = x + rx; -

2697 spans[current].y = y + ry; -

2698 spans[current].coverage = 255; -

2699 int len = 1; -

2700 ++x; -

2701 // extend span until we find a different one. -

2702 while (x < x1 && monoVal(scanline, x)) { -

2703 ++x; -

2704 ++len; -

2705 } -

2706 spans[current].len = len; -

2707 ++current; -

2708 } -

2709 scanline += bpl; -

2710 } -

2711 } else if (depth == 8) { -

2712 for (int y = y0; y < y1; ++y) { -

2713 for (int x = x0; x < x1; ) { -

2714 // Skip those with 0 coverage -

2715 if (scanline[x] == 0) { -

2716 ++x; -

2717 continue; -

2718 } -

2719 -

2720 if (current == NSPANS) { -

2721 blend(current, spans, &s->penData); -

2722 current = 0; -

2723 } -

2724 int coverage = scanline[x]; -

2725 spans[current].x = x + rx; -

2726 spans[current].y = y + ry; -

2727 spans[current].coverage = coverage; -

2728 int len = 1; -

2729 ++x; -

2730 -

2731 // extend span until we find a different one. -

2732 while (x < x1 && scanline[x] == coverage) { -

2733 ++x; -

2734 ++len; -

2735 } -

2736 spans[current].len = len; -

2737 ++current; -

2738 } -

2739 scanline += bpl; -

2740 } -

2741 } else { // 32-bit alpha... -

2742 uint *sl = (uint *) src; -

2743 for (int y = y0; y < y1; ++y) { -

2744 for (int x = x0; x < x1; ) { -

2745 // Skip those with 0 coverage -

2746 if ((sl[x] & 0x00ffffff) == 0) { -

2747 ++x; -

2748 continue; -

2749 } -

2750 -

2751 if (current == NSPANS) { -

2752 blend(current, spans, &s->penData); -

2753 current = 0; -

2754 } -

2755 uint rgbCoverage = sl[x]; -

2756 int coverage = qGreen(rgbCoverage); -

2757 spans[current].x = x + rx; -

2758 spans[current].y = y + ry; -

2759 spans[current].coverage = coverage; -

2760 int len = 1; -

2761 ++x; -

2762 -

2763 // extend span until we find a different one. -

2764 while (x < x1 && sl[x] == rgbCoverage) { -

2765 ++x; -

2766 ++len; -

2767 } -

2768 spans[current].len = len; -

2769 ++current; -

2770 } -

2771 sl += bpl / sizeof(uint); -

2772 } -

2773 } -

2774 // qDebug() << "alphaPenBlt: num spans=" << current -

2775 // << "span:" << spans->x << spans->y << spans->len << spans->coverage; -

2776 // Call span func for current set of spans. -

2777 if (current != 0) -

2778 blend(current, spans, &s->penData); -

2779 } -

2780 -

2781 /*! -

2782 \internal -

2783 */ -

2784 bool QRasterPaintEngine::drawCachedGlyphs(int numGlyphs, const glyph_t *glyphs, -

2785 const QFixedPoint *positions, QFontEngine *fontEngine) -

2786 { -

2787 Q_D(QRasterPaintEngine); -

2788 QRasterPaintEngineState *s = state(); -

2789 -

2790 if (fontEngine->hasInternalCaching()) { -

2791 QFontEngine::GlyphFormat neededFormat = -

2792 painter()->device()->devType() == QInternal::Widget -

2793 ? QFontEngine::Format_None -

2794 : QFontEngine::Format_A8; -

2795 -

2796 if (d_func()->mono_surface) // alphaPenBlt can handle mono, too -

2797 neededFormat = QFontEngine::Format_Mono; -

2798 -

2799 for (int i = 0; i < numGlyphs; i++) { -

2800 QFixed spp = fontEngine->subPixelPositionForX(positions[i].x); -

2801 -

2802 QPoint offset; -

2803 QImage *alphaMap = fontEngine->lockedAlphaMapForGlyph(glyphs[i], spp, neededFormat, s->matrix, -

2804 &offset); -

2805 if (alphaMap == 0 || alphaMap->isNull()) -

2806 continue; -

2807 -

2808 alphaPenBlt(alphaMap->bits(), alphaMap->bytesPerLine(), alphaMap->depth(), -

2809 qFloor(positions[i].x) + offset.x(), -

2810 qRound(positions[i].y) + offset.y(), -

2811 alphaMap->width(), alphaMap->height()); -

2812 -

2813 fontEngine->unlockAlphaMapForGlyph(); -

2814 } -

2815 -

2816 } else { -

2817 QFontEngineGlyphCache::Type glyphType = fontEngine->glyphFormat >= 0 ? QFontEngineGlyphCache::Type(fontEngine->glyphFormat) : d->glyphCacheType; -

2818 -

2819 QImageTextureGlyphCache *cache = -

2820 static_cast<QImageTextureGlyphCache *>(fontEngine->glyphCache(0, glyphType, s->matrix)); -

2821 if (!cache) { -

2822 cache = new QImageTextureGlyphCache(glyphType, s->matrix); -

2823 fontEngine->setGlyphCache(0, cache); -

2824 } -

2825 -

2826 cache->populate(fontEngine, numGlyphs, glyphs, positions); -

2827 cache->fillInPendingGlyphs(); -

2828 -

2829 const QImage &image = cache->image(); -

2830 int bpl = image.bytesPerLine(); -

2831 -

2832 int depth = image.depth(); -

2833 int rightShift = 0; -

2834 int leftShift = 0; -

2835 if (depth == 32) -

2836 leftShift = 2; // multiply by 4 -

2837 else if (depth == 1) -

2838 rightShift = 3; // divide by 8 -

2839 -

2840 int margin = fontEngine->glyphMargin(glyphType); -

2841 const uchar *bits = image.bits(); -

2842 for (int i=0; i<numGlyphs; ++i) { -

2843 -

2844 QFixed subPixelPosition = fontEngine->subPixelPositionForX(positions[i].x); -

2845 QTextureGlyphCache::GlyphAndSubPixelPosition glyph(glyphs[i], subPixelPosition); -

2846 const QTextureGlyphCache::Coord &c = cache->coords[glyph]; -

2847 if (c.isNull()) -

2848 continue; -

2849 -

2850 int x = qFloor(positions[i].x) + c.baseLineX - margin; -

2851 int y = qRound(positions[i].y) - c.baseLineY - margin; -

2852 -

2853 // printf("drawing [%d %d %d %d] baseline [%d %d], glyph: %d, to: %d %d, pos: %d %d\n", -

2854 // c.x, c.y, -

2855 // c.w, c.h, -

2856 // c.baseLineX, c.baseLineY, -

2857 // glyphs[i], -

2858 // x, y, -

2859 // positions[i].x.toInt(), positions[i].y.toInt()); -

2860 -

2861 alphaPenBlt(bits + ((c.x << leftShift) >> rightShift) + c.y * bpl, bpl, depth, x, y, c.w, c.h); -

2862 } -

2863 } -

2864 return true; -

2865 } -

2866 -

2867 -

2868 /*! -

2869 * Returns true if the rectangle is completely within the current clip -

2870 * state of the paint engine. -

2871 */ -

2872 bool QRasterPaintEnginePrivate::isUnclipped_normalized(const QRect &r) const -

2873 { -

2874 const QClipData *cl = clip(); -

2875 if (!cl) { -

2876 // inline contains() for performance (we know the rects are normalized) -

2877 const QRect &r1 = deviceRect; -

2878 return (r.left() >= r1.left() && r.right() <= r1.right() -

2879 && r.top() >= r1.top() && r.bottom() <= r1.bottom()); -

2880 } -

2881 -

2882 -

2883 if (cl->hasRectClip) { -

2884 // currently all painting functions clips to deviceRect internally -

2885 if (cl->clipRect == deviceRect) -

2886 return true; -

2887 -

2888 // inline contains() for performance (we know the rects are normalized) -

2889 const QRect &r1 = cl->clipRect; -

2890 return (r.left() >= r1.left() && r.right() <= r1.right() -

2891 && r.top() >= r1.top() && r.bottom() <= r1.bottom()); -

2892 } else { -

2893 return qt_region_strictContains(cl->clipRegion, r); -

2894 } -

2895 } -

2896 -

2897 bool QRasterPaintEnginePrivate::isUnclipped(const QRect &rect, -

2898 int penWidth) const -

2899 { -

2900 Q_Q(const QRasterPaintEngine); -

2901 const QRasterPaintEngineState *s = q->state(); -

2902 const QClipData *cl = clip(); -

2903 if (!cl) { -

2904 QRect r = rect.normalized(); -

2905 // inline contains() for performance (we know the rects are normalized) -

2906 const QRect &r1 = deviceRect; -

2907 return (r.left() >= r1.left() && r.right() <= r1.right() -

2908 && r.top() >= r1.top() && r.bottom() <= r1.bottom()); -

2909 } -

2910 -

2911 -

2912 // currently all painting functions that call this function clip to deviceRect internally -

2913 if (cl->hasRectClip && cl->clipRect == deviceRect) -

2914 return true; -

2915 -

2916 if (s->flags.antialiased) -

2917 ++penWidth; -

2918 -

2919 QRect r = rect.normalized(); -

2920 if (penWidth > 0) { -

2921 r.setX(r.x() - penWidth); -

2922 r.setY(r.y() - penWidth); -

2923 r.setWidth(r.width() + 2 * penWidth); -

2924 r.setHeight(r.height() + 2 * penWidth); -

2925 } -

2926 -

2927 if (cl->hasRectClip) { -

2928 // inline contains() for performance (we know the rects are normalized) -

2929 const QRect &r1 = cl->clipRect; -

2930 return (r.left() >= r1.left() && r.right() <= r1.right() -

2931 && r.top() >= r1.top() && r.bottom() <= r1.bottom()); -

2932 } else { -

2933 return qt_region_strictContains(cl->clipRegion, r); -

2934 } -

2935 } -

2936 -

2937 inline bool QRasterPaintEnginePrivate::isUnclipped(const QRectF &rect, -

2938 int penWidth) const -

2939 { -

2940 return isUnclipped(rect.normalized().toAlignedRect(), penWidth); -

2941 } -

2942 -

2943 inline ProcessSpans -

2944 QRasterPaintEnginePrivate::getBrushFunc(const QRect &rect, -

2945 const QSpanData *data) const -

2946 { -

2947 return isUnclipped(rect, 0) ? data->unclipped_blend : data->blend; -

2948 } -

2949 -

2950 inline ProcessSpans -

2951 QRasterPaintEnginePrivate::getBrushFunc(const QRectF &rect, -

2952 const QSpanData *data) const -

2953 { -

2954 return isUnclipped(rect, 0) ? data->unclipped_blend : data->blend; -

2955 } -

2956 -

2957 inline ProcessSpans -

2958 QRasterPaintEnginePrivate::getPenFunc(const QRectF &rect, -

2959 const QSpanData *data) const -

2960 { -

2961 Q_Q(const QRasterPaintEngine); -

2962 const QRasterPaintEngineState *s = q->state(); -

2963 -

2964 if (!s->flags.fast_pen && s->matrix.type() > QTransform::TxTranslate) -

2965 return data->blend; -

2966 const int penWidth = s->flags.fast_pen ? 1 : qCeil(s->lastPen.widthF()); -

2967 return isUnclipped(rect, penWidth) ? data->unclipped_blend : data->blend; -

2968 } -

2969 -

2970 static QPair<int, int> visibleGlyphRange(const QRectF &clip, QFontEngine *fontEngine, -

2971 glyph_t *glyphs, QFixedPoint *positions, int numGlyphs) -

2972 { -

2973 QFixed clipLeft = QFixed::fromReal(clip.left()); -

2974 QFixed clipRight = QFixed::fromReal(clip.right()); -

2975 QFixed clipTop = QFixed::fromReal(clip.top()); -

2976 QFixed clipBottom = QFixed::fromReal(clip.bottom()); -

2977 -

2978 int first = 0; -

2979 while (first < numGlyphs) { -

2980 glyph_metrics_t metrics = fontEngine->boundingBox(glyphs[first]); -

2981 QFixed left = metrics.x + positions[first].x; -

2982 QFixed top = metrics.y + positions[first].y; -

2983 QFixed right = left + metrics.width; -

2984 QFixed bottom = top + metrics.height; -

2985 if (left < clipRight && right > clipLeft && top < clipBottom && bottom > clipTop) -

2986 break; -

2987 ++first; -

2988 } -

2989 int last = numGlyphs - 1; -

2990 while (last > first) { -

2991 glyph_metrics_t metrics = fontEngine->boundingBox(glyphs[last]); -

2992 QFixed left = metrics.x + positions[last].x; -

2993 QFixed top = metrics.y + positions[last].y; -

2994 QFixed right = left + metrics.width; -

2995 QFixed bottom = top + metrics.height; -

2996 if (left < clipRight && right > clipLeft && top < clipBottom && bottom > clipTop) -

2997 break; -

2998 --last; -

2999 } -

3000 return QPair<int, int>(first, last + 1); -

3001 } -

3002 -

3003 /*! -

3004 \reimp -

3005 */ -

3006 void QRasterPaintEngine::drawStaticTextItem(QStaticTextItem *textItem) -

3007 { -

3008 if (textItem->numGlyphs == 0) -

3009 return; -

3010 -

3011 ensurePen(); -

3012 ensureRasterState(); -

3013 -

3014 QFontEngine *fontEngine = textItem->fontEngine(); -

3015 if (!supportsTransformations(fontEngine)) { -

3016 drawCachedGlyphs(textItem->numGlyphs, textItem->glyphs, textItem->glyphPositions, -

3017 fontEngine); -

3018 } else if (state()->matrix.type() < QTransform::TxProject) { -

3019 bool invertible; -

3020 QTransform invMat = state()->matrix.inverted(&invertible); -

3021 if (!invertible) -

3022 return; -

3023 -

3024 QPair<int, int> range = visibleGlyphRange(invMat.mapRect(clipBoundingRect()), -

3025 textItem->fontEngine(), textItem->glyphs, -

3026 textItem->glyphPositions, textItem->numGlyphs); -

3027 QStaticTextItem copy = *textItem; -

3028 copy.glyphs += range.first; -

3029 copy.glyphPositions += range.first; -

3030 copy.numGlyphs = range.second - range.first; -

3031 QPaintEngineEx::drawStaticTextItem(&copy); -

3032 } else { -

3033 QPaintEngineEx::drawStaticTextItem(textItem); -

3034 } -

3035 } -

3036 -

3037 /*! -

3038 \reimp -

3039 */ -

3040 void QRasterPaintEngine::drawTextItem(const QPointF &p, const QTextItem &textItem) -

3041 { -

3042 const QTextItemInt &ti = static_cast<const QTextItemInt &>(textItem); -

3043 -

3044 #ifdef QT_DEBUG_DRAW -

3045 Q_D(QRasterPaintEngine); -

3046 fprintf(stderr," - QRasterPaintEngine::drawTextItem(), (%.2f,%.2f), string=%s ct=%d\n", -

3047 p.x(), p.y(), QString::fromRawData(ti.chars, ti.num_chars).toLatin1().data(), -

3048 d->glyphCacheType); -

3049 #endif -

3050 -

3051 if (ti.glyphs.numGlyphs == 0) -

3052 return; -

3053 ensurePen(); -

3054 ensureRasterState(); -

3055 -

3056 QRasterPaintEngineState *s = state(); -

3057 QTransform matrix = s->matrix; -

3058 -

3059 if (!supportsTransformations(ti.fontEngine)) { -

3060 QVarLengthArray<QFixedPoint> positions; -

3061 QVarLengthArray<glyph_t> glyphs; -

3062 -

3063 matrix.translate(p.x(), p.y()); -

3064 ti.fontEngine->getGlyphPositions(ti.glyphs, matrix, ti.flags, glyphs, positions); -

3065 -

3066 drawCachedGlyphs(glyphs.size(), glyphs.constData(), positions.constData(), ti.fontEngine); -

3067 } else if (matrix.type() < QTransform::TxProject) { -

3068 bool invertible; -

3069 QTransform invMat = matrix.inverted(&invertible); -

3070 if (!invertible) -

3071 return; -

3072 -

3073 QVarLengthArray<QFixedPoint> positions; -

3074 QVarLengthArray<glyph_t> glyphs; -

3075 -

3076 ti.fontEngine->getGlyphPositions(ti.glyphs, QTransform::fromTranslate(p.x(), p.y()), -

3077 ti.flags, glyphs, positions); -

3078 QPair<int, int> range = visibleGlyphRange(invMat.mapRect(clipBoundingRect()), -

3079 ti.fontEngine, glyphs.data(), positions.data(), -

3080 glyphs.size()); -

3081 -

3082 if (range.first >= range.second) -

3083 return; -

3084 -

3085 QStaticTextItem staticTextItem; -

3086 staticTextItem.color = s->pen.color(); -

3087 staticTextItem.font = s->font; -

3088 staticTextItem.setFontEngine(ti.fontEngine); -

3089 staticTextItem.numGlyphs = range.second - range.first; -

3090 staticTextItem.glyphs = glyphs.data() + range.first; -

3091 staticTextItem.glyphPositions = positions.data() + range.first; -

3092 QPaintEngineEx::drawStaticTextItem(&staticTextItem); -

3093 } else { -

3094 QPaintEngineEx::drawTextItem(p, ti); -

3095 } -

3096 } -

3097 -

3098 /*! -

3099 \reimp -

3100 */ -

3101 void QRasterPaintEngine::drawPoints(const QPointF *points, int pointCount) -

3102 { -

3103

never executed (the execution status of this line is deduced): QRasterPaintEnginePrivate * const d = d_func();

3104

never executed (the execution status of this line is deduced): QRasterPaintEngineState *s = state();

3105 -

3106

never executed (the execution status of this line is deduced): ensurePen();

3107

never evaluated: !s->penData.blend

3108

if (!s->flags.fast_pen) {

never executed: return;

3109 -

3110

never evaluated: !s->flags.fast_pen

3111

QPaintEngineEx::drawPoints(points, pointCount);

never executed (the execution status of this line is deduced): QPaintEngineEx::drawPoints(points, pointCount);

3112

QCosmeticStroker stroker(s, d->deviceRect, d->deviceRectUnclipped);

never executed: return;

3113 } -

3114 -

3115

never executed (the execution status of this line is deduced): QCosmeticStroker stroker(s, d->deviceRect, d->deviceRectUnclipped);

3116

stroker.setLegacyRoundingEnabled(s->flags.legacy_rounding);

never executed (the execution status of this line is deduced): stroker.setLegacyRoundingEnabled(s->flags.legacy_rounding);

3117

stroker.drawPoints(points, pointCount);

never executed (the execution status of this line is deduced): stroker.drawPoints(points, pointCount);

3118

never executed: }

3119 -

3120 -

3121 void QRasterPaintEngine::drawPoints(const QPoint *points, int pointCount) -

3122 { -

3123

executed (the execution status of this line is deduced): QRasterPaintEnginePrivate * const d = d_func();

3124

executed (the execution status of this line is deduced): QRasterPaintEngineState *s = state();

3125 -

3126

executed (the execution status of this line is deduced): ensurePen();

3127

partially evaluated: !s->penData.blend

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:136

0-136

3128

if (!s->flags.fast_pen) {

never executed: return;

3129 -

3130

evaluated: !s->flags.fast_pen

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:135

1-135

3131

QPaintEngineEx::drawPoints(points, pointCount);

executed (the execution status of this line is deduced): QPaintEngineEx::drawPoints(points, pointCount);

3132

QCosmeticStroker stroker(s, d->deviceRect, d->deviceRectUnclipped);

executed: return;

Execution Count:1

3133 } -

3134 -

3135

executed (the execution status of this line is deduced): QCosmeticStroker stroker(s, d->deviceRect, d->deviceRectUnclipped);

3136

stroker.setLegacyRoundingEnabled(s->flags.legacy_rounding);

executed (the execution status of this line is deduced): stroker.setLegacyRoundingEnabled(s->flags.legacy_rounding);

3137

stroker.drawPoints(points, pointCount);

executed (the execution status of this line is deduced): stroker.drawPoints(points, pointCount);

3138

executed: }

Execution Count:135

135

3139 -

3140 /*! -

3141 \reimp -

3142 */ -

3143 void QRasterPaintEngine::drawLines(const QLine *lines, int lineCount) -

3144 { -

3145 #ifdef QT_DEBUG_DRAW -

3146 qDebug() << " - QRasterPaintEngine::drawLines(QLine*)" << lineCount; -

3147 #endif -

3148

executed (the execution status of this line is deduced): QRasterPaintEnginePrivate * const d = d_func();

3149

executed (the execution status of this line is deduced): QRasterPaintEngineState *s = state();

3150 -

3151

executed (the execution status of this line is deduced): ensurePen();

3152

evaluated: !s->penData.blend

TRUE	FALSE
yes Evaluation Count:48	yes Evaluation Count:4988

48-4988

3153

executed: return;

Execution Count:48

3154 -

3155

QCosmeticStroker stroker(s, d->deviceRect, d->deviceRectUnclipped);

evaluated: s->flags.fast_pen

TRUE	FALSE
yes Evaluation Count:4933	yes Evaluation Count:55

55-4933

3156

executed (the execution status of this line is deduced): QCosmeticStroker stroker(s, d->deviceRect, d->deviceRectUnclipped);

3157

stroker.setLegacyRoundingEnabled(s->flags.legacy_rounding);

executed (the execution status of this line is deduced): stroker.setLegacyRoundingEnabled(s->flags.legacy_rounding);

3158

for (int i=0; i<lineCount; ++i) {

evaluated: i<lineCount

TRUE	FALSE
yes Evaluation Count:4933	yes Evaluation Count:4933

4933

3159

const QLine &l = lines[i];

executed (the execution status of this line is deduced): const QLine &l = lines[i];

3160

stroker.drawLine(l.p1(), l.p2());

executed (the execution status of this line is deduced): stroker.drawLine(l.p1(), l.p2());

3161

executed: }

Execution Count:4933

4933

3162

QPaintEngineEx::drawLines(lines, lineCount);

executed: }

Execution Count:4933

4933

3163

executed (the execution status of this line is deduced): QPaintEngineEx::drawLines(lines, lineCount);

3164

executed: }

Execution Count:55

3165 } -

3166 -

3167 void QRasterPaintEnginePrivate::rasterizeLine_dashed(QLineF line, -

3168 qreal width, -

3169 int *dashIndex, -

3170 qreal *dashOffset, -

3171 bool *inDash) -

3172 { -

3173 Q_Q(QRasterPaintEngine); -

3174 QRasterPaintEngineState *s = q->state(); -

3175 -

3176 const QPen &pen = s->lastPen; -

3177 const bool squareCap = (pen.capStyle() == Qt::SquareCap); -

3178 const QVector<qreal> pattern = pen.dashPattern(); -

3179 -

3180 qreal patternLength = 0; -

3181 for (int i = 0; i < pattern.size(); ++i) -

3182 patternLength += pattern.at(i); -

3183 -

3184 if (patternLength <= 0) -

3185 return; -

3186 -

3187 qreal length = line.length(); -

3188 Q_ASSERT(length > 0); -

3189 while (length > 0) { -

3190 const bool rasterize = *inDash; -

3191 qreal dash = (pattern.at(*dashIndex) - *dashOffset) * width; -

3192 QLineF l = line; -

3193 -

3194 if (dash >= length) { -

3195 dash = length; -

3196 *dashOffset += dash / width; -

3197 length = 0; -

3198 } else { -

3199 *dashOffset = 0; -

3200 *inDash = !(*inDash); -

3201 if (++*dashIndex >= pattern.size()) -

3202 *dashIndex = 0; -

3203 length -= dash; -

3204 l.setLength(dash); -

3205 line.setP1(l.p2()); -

3206 } -

3207 -

3208 if (rasterize && dash > 0) -

3209 rasterizer->rasterizeLine(l.p1(), l.p2(), width / dash, squareCap); -

3210 } -

3211 } -

3212 -

3213 /*! -

3214 \reimp -

3215 */ -

3216 void QRasterPaintEngine::drawLines(const QLineF *lines, int lineCount) -

3217 { -

3218 #ifdef QT_DEBUG_DRAW -

3219 qDebug() << " - QRasterPaintEngine::drawLines(QLineF *)" << lineCount; -

3220 #endif -

3221

executed (the execution status of this line is deduced): QRasterPaintEnginePrivate * const d = d_func();

3222

executed (the execution status of this line is deduced): QRasterPaintEngineState *s = state();

3223 -

3224

executed (the execution status of this line is deduced): ensurePen();

3225

evaluated: !s->penData.blend

TRUE	FALSE
yes Evaluation Count:48	yes Evaluation Count:1925

48-1925

3226

executed: return;

Execution Count:48

3227

QCosmeticStroker stroker(s, d->deviceRect, d->deviceRectUnclipped);

evaluated: s->flags.fast_pen

TRUE	FALSE
yes Evaluation Count:1106	yes Evaluation Count:819

819-1106

3228

executed (the execution status of this line is deduced): QCosmeticStroker stroker(s, d->deviceRect, d->deviceRectUnclipped);

3229

stroker.setLegacyRoundingEnabled(s->flags.legacy_rounding);

executed (the execution status of this line is deduced): stroker.setLegacyRoundingEnabled(s->flags.legacy_rounding);

3230

for (int i=0; i<lineCount; ++i) {

evaluated: i<lineCount

TRUE	FALSE
yes Evaluation Count:1595	yes Evaluation Count:1106

1106-1595

3231

QLineF line = lines[i];

executed (the execution status of this line is deduced): QLineF line = lines[i];

3232

stroker.drawLine(line.p1(), line.p2());

executed (the execution status of this line is deduced): stroker.drawLine(line.p1(), line.p2());

3233

executed: }

Execution Count:1595

1595

3234

QPaintEngineEx::drawLines(lines, lineCount);

executed: }

Execution Count:1106

1106

3235

executed (the execution status of this line is deduced): QPaintEngineEx::drawLines(lines, lineCount);

3236