void KstViewArrow::paintSelf(KstPainter& p, const QRegion& bounds) {
p.save();
if (p.type() != KstPainter::P_PRINT && p.type() != KstPainter::P_EXPORT) {
if (p.makingMask()) {
p.setCompositionMode(QPainter::CompositionMode_Source);
} else {
const QRegion clip(clipRegion());
KstViewLine::paintSelf(p, bounds - _myClipMask);
p.setClipRegion(bounds & clip);
}
} else {
KstViewLine::paintSelf(p, bounds);
}
if (hasArrow()) {
QPoint to = KstViewLine::to();
QPoint from = KstViewLine::from();
const int w = width() * p.lineWidthAdjustmentFactor();
QPen pen(_foregroundColor, w);
pen.setCapStyle(capStyle());
p.setPen(pen);
p.setBrush(_foregroundColor);
if (_hasToArrow) {
paintArrow(p, to, from, w, _toArrowScaling);
}
if (_hasFromArrow) {
paintArrow(p, from, to, w, _fromArrowScaling);
}
}
p.restore();
}
QRegion KstViewLegend::clipRegion() {
if (!_transparent) {
return KstBorderedViewObject::clipRegion();
}
if (_clipMask.isNull() && _myClipMask.isNull()) {
const QRect cr(contentsRect());
QBitmap bm = _backBuffer.buffer().createHeuristicMask(false); // slow but preserves antialiasing...
_myClipMask = QRegion(bm);
_myClipMask.translate(cr.topLeft().x(), cr.topLeft().y());
QBitmap bm1(_geom.bottomRight().x() + 1, _geom.bottomRight().y() + 1, true);
if (!bm1.isNull()) {
KstPainter p;
p.setMakingMask(true);
p.begin(&bm1);
p.setViewXForm(true);
KstBorderedViewObject::paintSelf(p, QRegion());
p.end();
_clipMask = QRegion(bm1);
}
}
return _clipMask | _myClipMask;
}
void KstViewLabel::paintSelf(KstPainter& p, const QRegion& bounds) {
p.save();
if (p.type() == KstPainter::P_PRINT || p.type() == KstPainter::P_EXPORT) {
int absFontSizeOld = _absFontSize;
QRect cr(contentsRectForPainter(p));
cr.setSize(sizeForText(_parent->geometry()));
setContentsRectForPainter(p, cr);
KstBorderedViewObject::paintSelf(p, bounds);
p.translate(cr.left(), cr.top());
if (!_transparent) {
p.fillRect(0, 0, cr.width(), cr.height(), backgroundColor());
}
drawToPainter(_parsed, p);
_absFontSize = absFontSizeOld;
} else {
if (p.makingMask()) {
KstBorderedViewObject::paintSelf(p, bounds);
p.setRasterOp(Qt::SetROP);
const QRect cr(contentsRect());
// slow but preserves antialiasing...
QBitmap bm = _backBuffer.buffer().createHeuristicMask(false);
bm.setMask(bm);
p.drawPixmap(cr.left(), cr.top(), bm, 0, 0, cr.width(), cr.height());
} else {
const QRegion clip(clipRegion());
KstBorderedViewObject::paintSelf(p, bounds);
p.setClipRegion(bounds & clip);
_backBuffer.paintInto(p, contentsRect());
}
}
p.restore();
}
QRegion KstViewArrow::clipRegion() {
if (_clipMask.isNull()) {
_myClipMask = QRegion();
QBitmap bm1(_geom.bottomRight().x(), _geom.bottomRight().y(), true);
if (!bm1.isNull()) {
KstPainter p;
p.setMakingMask(true);
p.begin(&bm1);
p.setViewXForm(true);
KstViewLine::paintSelf(p, QRegion());
p.end();
_clipMask = QRegion(bm1);
}
QBitmap bm2(_geom.bottomRight().x(), _geom.bottomRight().y(), true);
if (!bm2.isNull()) {
KstPainter p;
p.setMakingMask(true);
p.begin(&bm2);
p.setViewXForm(true);
paintSelf(p, QRegion());
p.end();
_myClipMask = QRegion(bm2);
}
}
return _myClipMask | _clipMask;
}
void KstTopLevelView::pressMoveLayoutModeMove(const QPoint& pos, bool shift) {
Q_UNUSED(shift)
const QRect old(_prevBand);
QRect r(_pressTarget->geometry());
for (KstViewObjectList::ConstIterator i = _selectionList.begin(); i != _selectionList.end(); ++i) {
r = r.unite((*i)->geometry());
}
const QPoint originalTopLeft(r.topLeft());
QPoint topLeft(pos - _moveOffset - _pressTarget->geometry().topLeft() + r.topLeft());
r.moveTopLeft(topLeft);
_moveOffsetSticky = QPoint(0, 0);
int xMin = STICKY_THRESHOLD;
int yMin = STICKY_THRESHOLD;
snapToBorders(&xMin, &yMin, _selectionList, _pressTarget, r);
if (labs(xMin) < STICKY_THRESHOLD) {
_moveOffsetSticky.setX(xMin);
topLeft.setX(topLeft.x() - xMin);
}
if (labs(yMin) < STICKY_THRESHOLD) {
_moveOffsetSticky.setY(yMin);
topLeft.setY(topLeft.y() - yMin);
}
r.moveTopLeft(topLeft);
if (!_geom.contains(r, true)) {
slideInto(_geom, r);
}
_prevBand = r;
if (_prevBand != old) {
KstPainter p;
p.begin(_w);
p.setRasterOp(Qt::NotROP);
p.setPen(QPen(Qt::black, 0, Qt::DotLine));
if (_selectionList.isEmpty()) {
if (old.topLeft() != QPoint(-1, -1)) {
_pressTarget->drawShadow(p, old.topLeft());
}
_pressTarget->drawShadow(p, r.topLeft());
} else {
for (KstViewObjectList::Iterator iter = _selectionList.begin(); iter != _selectionList.end(); ++iter) {
if (old.topLeft() != QPoint(-1, -1)) {
(*iter)->drawShadow(p, old.topLeft() + (*iter)->geometry().topLeft() - originalTopLeft);
}
(*iter)->drawShadow(p, r.topLeft() + (*iter)->geometry().topLeft() - originalTopLeft);
}
}
p.end();
}
}
void KstViewLegend::paintSelf(KstPainter& p, const QRegion& bounds) {
if (p.type() == KstPainter::P_PRINT || p.type() == KstPainter::P_EXPORT) {
p.save();
QRect cr(contentsRectForPainter(p));
cr.setSize(sizeForText(_parent->geometry()));
setContentsRectForPainter(p, cr);
KstBorderedViewObject::paintSelf(p, bounds);
p.translate(cr.left(), cr.top());
if (!_transparent) {
p.fillRect(0, 0, cr.width(), cr.height(), _backgroundColor);
}
drawToPainter(p);
p.restore();
} else {
const QRect cr(contentsRect());
if (p.makingMask()) {
p.setCompositionMode(QPainter::CompositionMode_Source);
} else {
const QRegion clip(clipRegion());
KstBorderedViewObject::paintSelf(p, bounds - _myClipMask);
p.setClipRegion(bounds & clip);
}
_backBuffer.paintInto(p, cr);
}
}
void KstViewLegend::drawToBuffer() {
setDirty(false);
_backBuffer.buffer().resize(contentsRect().size());
_backBuffer.buffer().fill(backgroundColor());
KstPainter p;
p.begin(&_backBuffer.buffer());
QPen pen;
pen.setColor(foregroundColor());
p.setPen(pen);
drawToPainter(p);
p.end();
}
void KstBorderedViewObject::setContentsRectForDevice(const KstPainter& painter, QRect& rect) {
const int mpb = (_margin + _padding + _borderWidth) * painter.lineWidthAdjustmentFactor();
_geom.setX(rect.left() - mpb);
_geom.setY(rect.top() - mpb);
_geom.setWidth(rect.width() + 2 * mpb);
_geom.setHeight(rect.height() + 2 * mpb);
}
void KstPlotGroup::paintSelf(KstPainter& p, const QRegion& bounds) {
if (!transparent()) {
p.save();
// fill non-children areas with color
QRegion clipRegion(contentsRect());
QBrush brush(_backgroundColor);
for (KstViewObjectList::Iterator i = _children.begin(); i != _children.end(); ++i) {
clipRegion -= (*i)->clipRegion();
}
p.setClipRegion(clipRegion);
p.fillRect(contentsRect(), brush);
p.restore();
}
KstMetaPlot::paintSelf(p, bounds);
}
QRect KstBorderedViewObject::contentsRectForDevice(const KstPainter& painter) const {
QRect rc;
const int mpb = (_margin + _padding + _borderWidth) * painter.lineWidthAdjustmentFactor();
rc.setX(_geom.left() + mpb);
rc.setY(_geom.top() + mpb);
rc.setWidth(_geom.width() - 2 * mpb);
rc.setHeight(_geom.height() - 2 * mpb);
return rc;
}
void KstViewLine::drawFocusRect(KstPainter& p) {
// draw the hotpoints
QPoint point1, point2;
const int dx = KST_RESIZE_BORDER_W/2;
const QRect geom(geometry());
if (_orientation == UpLeft || _orientation == DownRight) {
point1 = QPoint(geom.left() - dx, geom.top() - dx);
point2 = QPoint(geom.right() - dx, geom.bottom() - dx);
} else {
point1 = QPoint(geom.right() - dx, geom.top() - dx);
point2 = QPoint(geom.left() - dx, geom.bottom() - dx);
}
QRect rect;
rect.setSize(QSize(2 * dx + 1, 2 * dx + 1));
rect.moveTopLeft(point1);
p.drawRect(rect);
rect.moveTopLeft(point2);
p.drawRect(rect);
}
void KstTopLevelView::pressMoveLayoutModeEndPoint(const QPoint& pos, bool maintainAspect) {
// FIXME: remove this!! Should not know about any specific type
// for now we only know how to deal with lines
QRect bounds = _pressTarget->_parent->geometry();
QPoint npos = pos;
//pos must be inside the parent
npos.setX(QMAX(npos.x(), bounds.left()));
npos.setX(QMIN(npos.x(), bounds.right()));
npos.setY(QMIN(npos.y(), bounds.bottom()));
npos.setY(QMAX(npos.y(), bounds.top()));
if (KstViewLinePtr line = kst_cast<KstViewLine>(_pressTarget)) {
QPoint movePoint, anchorPoint;
QPoint *fromPoint, *toPoint;
if (_pressDirection & UP) {
// UP means we are on the start endpoint
movePoint = line->from();
anchorPoint = line->to();
fromPoint = &movePoint;
toPoint = &anchorPoint;
} else { // (_pressDirection & DOWN)
// DOWN means we are on the end endpoint
movePoint = line->to();
anchorPoint = line->from();
fromPoint = &anchorPoint;
toPoint = &movePoint;
}
if (maintainAspect) {
movePoint = KstGfxMouseHandlerUtils::findNearestPtOnLine(anchorPoint, movePoint, npos, bounds);
} else {
movePoint = npos; // already enforced pos inside parent.
}
const QRect old(_prevBand);
_prevBand.setTopLeft(*fromPoint);
_prevBand.setBottomRight(*toPoint);
if (old != _prevBand) {
KstPainter p;
p.begin(_w);
p.setPen(QPen(Qt::black, 0, Qt::DotLine));
p.setRasterOp(Qt::NotROP);
if (old.topLeft() != QPoint(-1, -1)) {
p.drawLine(old.topLeft(), old.bottomRight());
}
p.drawLine(_prevBand.topLeft(), _prevBand.bottomRight());
p.end();
}
}
}
void KstViewLine::drawShadow(KstPainter& p, const QPoint& pos) {
QPoint point1, point2;
QRect rect = geometry();
rect.moveTopLeft(pos);
if (_orientation == UpLeft || _orientation == DownRight) {
point1 = pos;
point2 = rect.bottomRight();
} else {
point1 = rect.topRight();
point2 = rect.bottomLeft();
}
p.drawLine(point1, point2);
}
void KstTopLevelView::pressMoveLayoutModeResize(const QPoint& pos, bool maintainAspect) {
const QRect old(_prevBand);
_prevBand = newSize(_pressTarget->geometry(), _pressTarget->_parent->geometry(), _pressDirection, pos, maintainAspect);
if (_prevBand != old) {
KstPainter p;
p.begin(_w);
p.setRasterOp(Qt::NotROP);
p.setPen(QPen(Qt::black, 0, Qt::DotLine));
if (old.topLeft() != QPoint(-1, -1)) {
p.drawRect(old);
}
p.drawRect(_prevBand);
p.end();
}
}
void KstViewArrow::paintArrow(KstPainter& p, const QPoint& to, const QPoint &from, int w, double scaling) {
double deltax = scaling * 2.0 * double(w);
double theta = atan2(double(from.y() - to.y()), double(from.x() - to.x())) - M_PI / 2.0;
double sina = sin(theta);
double cosa = cos(theta);
double yin = sqrt(3.0) * deltax;
double x1, y1, x2, y2;
QMatrix m(cosa, sina, -sina, cosa, 0.0, 0.0);
m.map( deltax, yin, &x1, &y1);
m.map(-deltax, yin, &x2, &y2);
Q3PointArray pts(3);
pts[0] = to;
pts[1] = to + QPoint(d2i(x1), d2i(y1));
pts[2] = to + QPoint(d2i(x2), d2i(y2));
p.drawPolygon(pts);
}
void KstTopLevelView::pressMoveLayoutModeCenteredResize(const QPoint& pos, bool maintainAspect) {
//centered resize means that the center of the object stays constant
const QRect old(_prevBand);
_prevBand = newSizeCentered(_pressTarget->geometry(), _pressTarget->_parent->geometry(), pos, maintainAspect);
if (_prevBand != old) {
KstPainter p;
p.begin(_w);
p.setPen(QPen(Qt::black, 0, Qt::DotLine));
p.setRasterOp(Qt::NotROP);
if (old.topLeft() != QPoint(-1, -1)) {
p.drawEllipse(old);
}
p.drawEllipse(_prevBand);
p.end();
}
}
void KstTopLevelView::updateFocus(const QPoint& pos) {
if (_activeHandler) {
_activeHandler->updateFocus(this, pos);
return;
}
if (_mode == DisplayMode || _mode == Unknown || tracking()) {
return;
}
//TODO: make this work better with click-select mode
KstViewObjectPtr p = findDeepestChild(pos, false);
if (p) {
KstViewObjectPtr p2 = p;
while (p2->_parent && p2->_parent->_container) {
p2 = p2->_parent;
}
if (p2->_parent && !p2->_parent->_container) {
p = p2->_parent;
}
}
if (p) {
if (p->focused()) {
setCursorFor(pos, p);
_focusOn = true; // just in case - seems to be false on occasion
return;
}
p->setFocus(true);
if (_focusOn) { // something else has the focus, clear it
clearFocus();
}
setCursorFor(pos, p);
KstPainter painter;
painter.begin(_w);
painter.setRasterOp(Qt::NotROP);
painter.setPen(QPen(Qt::black, 0, Qt::SolidLine));
painter.setBrush(Qt::NoBrush);
p->drawFocusRect(painter);
painter.end();
_focusOn = true;
_hoverFocus = p;
} else {
clearFocus();
}
}
void KstTopLevelView::pressMoveLayoutModeSelect(const QPoint& pos, bool shift) {
Q_UNUSED(shift)
const QRect old(_prevBand);
QRect r;
r.setTopLeft(_moveOffset);
r.setBottomRight(pos);
_prevBand = r.normalize().intersect(_geom);
if (old != _prevBand) {
KstPainter p;
p.begin(_w);
p.setRasterOp(Qt::NotROP);
p.drawWinFocusRect(old);
p.drawWinFocusRect(_prevBand);
p.end();
}
KstApp::inst()->slotUpdateDataMsg(QString::null);
}
void KstTopLevelView::clearFocus() {
if (_focusOn) {
_pressDirection = -1;
_moveOffset = QPoint(-1, -1);
_moveOffsetSticky = QPoint(0, 0);
_w->unsetCursor();
_focusOn = false;
//recursively<bool>(&KstViewObject::setFocus, false);
if (_hoverFocus) {
KstPainter p;
p.begin(_w);
p.setViewXForm(true);
_hoverFocus->setFocus(false);
p.setRasterOp(Qt::NotROP);
p.setPen(QPen(Qt::black, 0, Qt::SolidLine));
p.setBrush(Qt::NoBrush);
_hoverFocus->drawFocusRect(p);
p.end();
_hoverFocus = 0L;
}
}
}
void KstBorderedViewObject::paintSelf(KstPainter& p, const QRegion& bounds) {
p.save();
if (p.type() != KstPainter::P_PRINT && p.type() != KstPainter::P_EXPORT) {
if (p.makingMask()) {
p.setRasterOp(Qt::SetROP);
KstViewObject::paintSelf(p, bounds);
} else {
const QRegion clip(clipRegion());
KstViewObject::paintSelf(p, bounds - clip);
p.setClipRegion(bounds & clip);
}
}
if (_borderWidth > 0) {
QRect r;
const int bw(_borderWidth * p.lineWidthAdjustmentFactor());
QPen pen(_borderColor, bw);
p.setBrush(Qt::NoBrush);
p.setPen(pen);
r.setX(_geom.left() + _margin + bw / 2);
r.setY(_geom.top() + _margin + bw / 2);
r.setWidth(_geom.width() - 2 * _margin - bw + 1);
r.setHeight(_geom.height() - 2 * _margin - bw + 1);
p.drawRect(r);
}
p.restore();
}
QRegion KstViewPicture::clipRegion() {
if (_clipMask.isNull()) {
_myClipMask = QRegion();
QBitmap bm1(_geom.bottomRight().x() + 1, _geom.bottomRight().y() + 1, true);
if (!bm1.isNull()) {
KstPainter p;
p.setMakingMask(true);
p.begin(&bm1);
p.setViewXForm(true);
KstBorderedViewObject::paintSelf(p, QRegion());
p.flush();
p.end();
_clipMask = QRegion(bm1);
}
QBitmap bm2(_geom.bottomRight().x() + 1, _geom.bottomRight().y() + 1, true);
if (!bm2.isNull()) {
KstPainter p;
p.setMakingMask(true);
p.begin(&bm2);
p.setViewXForm(true);
paintSelf(p, QRegion());
p.flush();
p.end();
_myClipMask = QRegion(bm2);
}
}
return _myClipMask | _clipMask;
}
void KstViewLegend::drawToPainter(KstPainter& p) {
RenderContext rc(_fontName, _absFontSize, &p);
if (_vertical) {
unsigned i = 0;
if (!_title.isEmpty()) {
p.save();
p.translate(_legendMargin*_ascent/10, _legendMargin*_ascent/10);
rc.x = 0;
rc.y = _ascent;
rc.xStart = rc.x;
renderLabel(rc, _parsedTitle->chunk);
i = 1;
p.restore();
}
for (KstBaseCurveList::Iterator it = _curves.begin(); it != _curves.end(); ++it) {
p.save();
if ((*it)->parsedLegendTag()) {
p.translate(_legendMargin*_ascent/10, _legendMargin*_ascent/10 + i * (rc.fontHeight() + _ascent / 4));
QRect symbolBound(QPoint(0,0), QSize(16*_ascent/4, rc.fontHeight()));
(*it)->paintLegendSymbol(&p, symbolBound);
p.translate(9*_ascent/2, 0);
rc.x = 0;
rc.y = _ascent;
rc.xStart = rc.x;
renderLabel(rc, (*it)->parsedLegendTag()->chunk);
}
p.restore();
++i;
}
} else {
p.save();
p.translate(_legendMargin*_ascent/10, _legendMargin*_ascent/10);
if (!_title.isEmpty()) {
rc.x = 0;
rc.y = _ascent;
rc.xStart = rc.x;
renderLabel(rc, _parsedTitle->chunk);
p.translate(_titleWidth + _ascent,0);
}
for (KstBaseCurveList::Iterator it = _curves.begin(); it != _curves.end(); ++it) {
if ((*it)->parsedLegendTag()) {
QRect symbolBound(QPoint(0,0),
QSize(16*_ascent/4, rc.fontHeight()));
(*it)->paintLegendSymbol(&p, symbolBound);
p.translate(9*_ascent/2, 0);
rc.x = 0;
rc.y = _ascent;
rc.xStart = rc.x;
renderLabel(rc, (*it)->parsedLegendTag()->chunk);
p.translate((*it)->legendLabelSize().width() + _ascent,0);
}
}
p.restore();
}
QApplication::syncX();
}
void KstViewBox::paintSelf(KstPainter& p, const QRegion& bounds) {
p.save();
if (p.type() != KstPainter::P_PRINT && p.type() != KstPainter::P_EXPORT) {
if (p.makingMask()) {
p.setRasterOp(Qt::SetROP);
} else {
const QRegion clip(clipRegion());
KstViewObject::paintSelf(p, bounds - clip);
p.setClipRegion(bounds & clip);
}
}
// restrict the border width so we do not draw outside of the rectangle itself
int bw(borderWidth() * p.lineWidthAdjustmentFactor());
if (bw > _geom.width() / 2) {
bw = _geom.width() / 2;
}
if (bw > _geom.height()) {
bw = _geom.height() / 2;
}
QPen pen(borderColor(), bw);
pen.setJoinStyle(_cornerStyle);
if (bw == 0) {
pen.setStyle(Qt::NoPen);
}
p.setPen(pen);
if (_transparentFill) {
p.setBrush(Qt::NoBrush);
} else {
p.setBrush(_foregroundColor);
}
QRect r;
r.setX(_geom.left() + bw / 2);
r.setY(_geom.top() + bw / 2);
r.setWidth(_geom.width() - bw);
r.setHeight(_geom.height() - bw);
p.drawRoundRect(r, _xRound, _yRound);
p.restore();
}
void KstViewLine::paintSelf(KstPainter& p, const QRegion& bounds) {
p.save();
if (p.type() != KstPainter::P_PRINT && p.type() != KstPainter::P_EXPORT) {
if (p.makingMask()) {
p.setRasterOp(Qt::SetROP);
KstViewObject::paintSelf(p, geometry());
} else {
const QRegion clip(clipRegion());
KstViewObject::paintSelf(p, bounds - clip);
p.setClipRegion(bounds & clip);
}
}
// figure out which direction to draw the line
const int w(_width * p.lineWidthAdjustmentFactor());
QPen pen(_foregroundColor, w);
pen.setCapStyle(_capStyle);
pen.setStyle(_penStyle);
p.setPen(pen);
const QRect geom(geometry());
int u = 0, v = 0;
// Adjust for large widths. We don't want the line clipped because it goes
// out of the bounding box.
if (w > 1 && geom.height() > 0) {
double theta = atan(geom.width()/geom.height());
if (theta >= 0 && theta <= M_PI/4) {
u = int(fabs((w / 2.0) * (sin(theta) + cos(theta))));
v = int(fabs((w / 2.0) * (1.5*sin(theta) + 0.5*cos(theta))));
} else {
u = int(fabs((w / 2.0) * (1.5*sin(theta) + 0.5*cos(theta))));
v = int(fabs((w / 2.0) * (sin(theta) + cos(theta))));
}
}
switch (_orientation) {
case UpLeft:
case DownRight:
p.drawLine(geom.bottomRight() + QPoint(-u, -v), geom.topLeft() + QPoint(u, v));
break;
case UpRight:
case DownLeft:
p.drawLine(geom.bottomLeft() + QPoint(u, -v), geom.topRight() + QPoint(-u, v));
break;
}
p.restore();
}
void KstViewLine::drawSelectRect(KstPainter& p) {
p.setPen(QPen(Qt::black, 0));
p.setBrush(QBrush(Qt::green, Qt::SolidPattern));
drawFocusRect(p);
}
void KstViewPicture::paintSelf(KstPainter& p, const QRegion& bounds) {
p.save();
if (p.type() != KstPainter::P_PRINT && p.type() != KstPainter::P_EXPORT) {
if (p.makingMask()) {
p.setRasterOp(Qt::OrROP);
} else {
const QRegion clip(clipRegion());
KstBorderedViewObject::paintSelf(p, bounds - _myClipMask);
p.setClipRegion(bounds & clip);
}
} else {
KstBorderedViewObject::paintSelf(p, bounds);
}
const QRect cr(contentsRectForDevice(p));
if (_image.isNull()) {
// fill with X
p.setBrush(QBrush(Qt::gray, Qt::SolidPattern));
p.setPen(QPen(Qt::black, 0, Qt::SolidLine));
p.drawRect(cr);
p.drawLine(cr.topLeft(), cr.bottomRight());
p.drawLine(cr.topRight(), cr.bottomLeft());
} else {
assert(!cr.isNull()); // Null view objects are not allowed. I want to see
// how this happens so it can be fixed.
if (_iCache.isNull() || _iCache.size() != cr.size()) {
_iCache = _image.copy();
if (!_iCache.isNull()) {
_iCache = _iCache.smoothScale(cr.size());
}
}
if (!_iCache.isNull()) {
if (p.makingMask()) {
// which indicates clipping / BW mode
if (_iCache.hasAlphaBuffer()) {
p.drawImage(cr.topLeft(), _iCache.createAlphaMask());
} else {
p.setBrush(Qt::color1);
p.drawRect(cr);
}
} else {
p.drawImage(cr.topLeft(), _iCache);
}
}
}
p.restore();
}
