void QPdfEngine::drawPixmap (const QRectF &rectangle, const QPixmap &pixmap, const QRectF &sr)
{
if (sr.isEmpty() || rectangle.isEmpty() || pixmap.isNull())
return;
Q_D(QPdfEngine);
QBrush b = d->brush;
QRect sourceRect = sr.toRect();
QPixmap pm = sourceRect != pixmap.rect() ? pixmap.copy(sourceRect) : pixmap;
QImage image = pm.toImage();
bool bitmap = true;
const int object = d->addImage(image, &bitmap, pm.cacheKey());
if (object < 0)
return;
*d->currentPage << "q\n/GSa gs\n";
*d->currentPage
<< QPdf::generateMatrix(QTransform(rectangle.width() / sr.width(), 0, 0, rectangle.height() / sr.height(),
rectangle.x(), rectangle.y()) * (d->simplePen ? QTransform() : d->stroker.matrix));
if (bitmap) {
// set current pen as d->brush
d->brush = d->pen.brush();
}
setBrush();
d->currentPage->streamImage(image.width(), image.height(), object);
*d->currentPage << "Q\n";
d->brush = b;
}
void X11FilterContext::drawPlainText(const QRectF &rect, int flags, const QString &text)
{
if (text.isEmpty())
return;
if (rect.isEmpty()) {
drawPlainText(rect.topLeft(), text);
return;
}
if (test_img.size() != rect.size().toSize()) {
test_img = QImage(rect.size().toSize(), QImage::Format_ARGB32); //TODO: create once
}
painter->begin(&test_img);
prepare();
QRectF br = painter->boundingRect(rect, flags, text);
painter->end();
if (br.isEmpty())
return;
if (text == this->text && plain && mask_pix) {
renderTextImageX11(0, br.topLeft());
return;
}
this->text = text;
this->plain = true;
text_q = QImage(br.size().toSize(), QImage::Format_ARGB32);
text_q.fill(QColor(0, 0, 0, 0));
painter->begin(&text_q);
prepare();
painter->drawText(0, 0, br.width(), br.height(), Qt::AlignCenter, text);
painter->end();
renderTextImageX11(&text_q, br.topLeft());
}
/*!
\brief Render the plot to a QSvgGenerator
If the generator has a view box, the plot will be rendered into it.
If it has no viewBox but a valid size the target coordinates
will be (0, 0, generator.width(), generator.height()). Otherwise
the target rectangle will be QRectF(0, 0, 800, 600);
\param plot Plot to be rendered
\param generator SVG generator
*/
void QwtPolarRenderer::renderTo(
QwtPolarPlot *plot, QSvgGenerator &generator ) const
{
QRectF rect = generator.viewBoxF();
if ( rect.isEmpty() )
rect.setRect( 0, 0, generator.width(), generator.height() );
if ( rect.isEmpty() )
rect.setRect( 0, 0, 800, 600 ); // something
QPainter p( &generator );
render( plot, &p, rect );
}
QImage QwtPlotRasterItem::compose(
const QwtScaleMap &xMap, const QwtScaleMap &yMap,
const QRectF &imageArea, const QRectF &paintRect,
const QSize &imageSize, bool doCache) const
{
QImage image;
if ( imageArea.isEmpty() || paintRect.isEmpty() || imageSize.isEmpty() )
return image;
if ( doCache )
{
if ( !d_data->cache.image.isNull()
&& d_data->cache.area == imageArea
&& d_data->cache.size == paintRect.size() )
{
image = d_data->cache.image;
}
}
if ( image.isNull() )
{
double dx = 0.0;
if ( paintRect.toRect().width() > imageSize.width() )
dx = imageArea.width() / imageSize.width();
const QwtScaleMap xxMap =
imageMap(Qt::Horizontal, xMap, imageArea, imageSize, dx);
double dy = 0.0;
if ( paintRect.toRect().height() > imageSize.height() )
dy = imageArea.height() / imageSize.height();
const QwtScaleMap yyMap =
imageMap(Qt::Vertical, yMap, imageArea, imageSize, dy);
image = renderImage( xxMap, yyMap, imageArea, imageSize );
if ( doCache )
{
d_data->cache.area = imageArea;
d_data->cache.size = paintRect.size();
d_data->cache.image = image;
}
}
if ( d_data->alpha >= 0 && d_data->alpha < 255 )
image = toRgba( image, d_data->alpha );
return image;
}
QVariant ComplexControlModel::doData(int row, int column, int role) const
{
if (role == Qt::DecorationRole) {
QPixmap pixmap(m_interface->cellSizeHint());
QPainter painter(&pixmap);
Util::drawTransparencyPattern(&painter, pixmap.rect());
painter.scale(m_interface->cellZoom(), m_interface->cellZoom());
QScopedPointer<QStyleOptionComplex> opt(
qstyleoption_cast<QStyleOptionComplex*>(complexControlElements[row].styleOptionFactory()));
Q_ASSERT(opt);
fillStyleOption(opt.data(), column);
m_style->drawComplexControl(complexControlElements[row].control, opt.data(), &painter);
int colorIndex = 7;
for (int i = 0; i < 32; ++i) {
QStyle::SubControl sc = static_cast<QStyle::SubControl>(1 << i);
if (sc & complexControlElements[row].subControls) {
QRectF scRect =
m_style->subControlRect(complexControlElements[row].control, opt.data(), sc);
scRect.adjust(0, 0, -1.0 / m_interface->cellZoom(), -1.0 / m_interface->cellZoom());
if (scRect.isValid() && !scRect.isEmpty()) {
// HACK: add some real color mapping
painter.setPen(static_cast<Qt::GlobalColor>(colorIndex++));
painter.drawRect(scRect);
}
}
}
return pixmap;
}
return AbstractStyleElementStateTable::doData(row, column, role);
}
static inline void qwtDrawSvgSymbols( QPainter *painter,
const QPointF *points, int numPoints,
QSvgRenderer *renderer, const QwtSymbol &symbol )
{
if ( renderer == NULL || !renderer->isValid() )
return;
const QRectF viewBox = renderer->viewBoxF();
if ( viewBox.isEmpty() )
return;
QSizeF sz = symbol.size();
if ( !sz.isValid() )
sz = viewBox.size();
const double sx = sz.width() / viewBox.width();
const double sy = sz.height() / viewBox.height();
QPointF pinPoint = viewBox.center();
if ( symbol.isPinPointEnabled() )
pinPoint = symbol.pinPoint();
const double dx = sx * ( pinPoint.x() - viewBox.left() );
const double dy = sy * ( pinPoint.y() - viewBox.top() );
for ( int i = 0; i < numPoints; i++ )
{
const double x = points[i].x() - dx;
const double y = points[i].y() - dy;
renderer->render( painter,
QRectF( x, y, sz.width(), sz.height() ) );
}
}
void QBlitterPaintEnginePrivate::clipAndDrawPixmap(const QRectF &clip, const QRectF &target, const QPixmap &pm, const QRectF &sr, bool opacity)
{
Q_Q(QBlitterPaintEngine);
QRectF intersectedRect = clip.intersected(target);
if (intersectedRect.isEmpty())
return;
QRectF source = sr;
if (intersectedRect.size() != target.size()) {
if (sr.size() == target.size()) {
// no resize
qreal deltaTop = target.top() - intersectedRect.top();
qreal deltaLeft = target.left() - intersectedRect.left();
qreal deltaBottom = target.bottom() - intersectedRect.bottom();
qreal deltaRight = target.right() - intersectedRect.right();
source.adjust(-deltaLeft, -deltaTop, -deltaRight, -deltaBottom);
} else {
// resize case
qreal hFactor = sr.size().width() / target.size().width();
qreal vFactor = sr.size().height() / target.size().height();
qreal deltaTop = (target.top() - intersectedRect.top()) * vFactor;
qreal deltaLeft = (target.left() - intersectedRect.left()) * hFactor;
qreal deltaBottom = (target.bottom() - intersectedRect.bottom()) * vFactor;
qreal deltaRight = (target.right() - intersectedRect.right()) * hFactor;
source.adjust(-deltaLeft, -deltaTop, -deltaRight, -deltaBottom);
}
}
pmData->unmarkRasterOverlay(intersectedRect);
if (opacity)
pmData->blittable()->drawPixmapOpacity(intersectedRect, pm, source, q->state()->compositionMode(), q->state()->opacity);
else
pmData->blittable()->drawPixmap(intersectedRect, pm, source);
}
void KisPerspectiveTransformWorker::runPartialDst(KisPaintDeviceSP srcDev,
KisPaintDeviceSP dstDev,
const QRect &dstRect)
{
if (m_isIdentity) {
KisPainter::copyAreaOptimizedOldData(dstRect.topLeft(), srcDev, dstDev, dstRect);
return;
}
QRectF srcClipRect = srcDev->exactBounds();
if (srcClipRect.isEmpty()) return;
KisProgressUpdateHelper progressHelper(m_progressUpdater, 100, dstRect.height());
KisRandomSubAccessorSP srcAcc = srcDev->createRandomSubAccessor();
KisRandomAccessorSP accessor = dstDev->createRandomAccessorNG(dstRect.x(), dstRect.y());
for (int y = dstRect.y(); y < dstRect.y() + dstRect.height(); ++y) {
for (int x = dstRect.x(); x < dstRect.x() + dstRect.width(); ++x) {
QPointF dstPoint(x, y);
QPointF srcPoint = m_backwardTransform.map(dstPoint);
if (srcClipRect.contains(srcPoint)) {
accessor->moveTo(dstPoint.x(), dstPoint.y());
srcAcc->moveTo(srcPoint.x(), srcPoint.y());
srcAcc->sampledOldRawData(accessor->rawData());
}
}
progressHelper.step();
}
}
void KisSketchView::geometryChanged(const QRectF& newGeometry, const QRectF& oldGeometry)
{
if (d->canvasWidget && !newGeometry.isEmpty()) {
d->view->resize(newGeometry.toRect().size());
// If we don't ask for this event to be sent, the view does not actually handle
// the resize, and we're stuck with a very oddly sized viewport
QResizeEvent *event = new QResizeEvent(newGeometry.toRect().size(), d->view->size());
QApplication::sendEvent(d->view, event);
// This is a touch on the hackish side - i'm sure there's a better way of doing it
// but it's taking a long time to work it out. Problem: When switching orientation,
// the canvas is rendered wrong, in what looks like an off-by-one ish kind of fashion.
if (oldGeometry.height() == oldGeometry.width() && oldGeometry.height() == newGeometry.width()) {
// in this case, we've just rotated the display... do something useful!
// Turns out we get /two/ resize events per rotation, one one per setting each height and width.
// So we can't just check it normally. Annoying, but there you go.
QTimer::singleShot(100, this, SLOT(centerDoc()));
QTimer::singleShot(150, this, SLOT(zoomOut()));
}
if (oldGeometry.height() == oldGeometry.width() && oldGeometry.width() == newGeometry.height()) {
// in this case, we've just rotated the display... do something useful!
// Turns out we get /two/ resize events per rotation, one one per setting each height and width.
// So we can't just check it normally. Annoying, but there you go.
QTimer::singleShot(100, this, SLOT(centerDoc()));
QTimer::singleShot(150, this, SLOT(zoomOut()));
}
}
}
void KPathShapePrivate::applyViewboxTransformation(const KXmlElement &element)
{
Q_Q(KPathShape);
// apply viewbox transformation
QRectF viewBox = q->loadOdfViewbox(element);
if (! viewBox.isEmpty()) {
// load the desired size
QSizeF size;
size.setWidth(KUnit::parseValue(element.attributeNS(KOdfXmlNS::svg, "width", QString())));
size.setHeight(KUnit::parseValue(element.attributeNS(KOdfXmlNS::svg, "height", QString())));
// load the desired position
QPointF pos;
pos.setX(KUnit::parseValue(element.attributeNS(KOdfXmlNS::svg, "x", QString())));
pos.setY(KUnit::parseValue(element.attributeNS(KOdfXmlNS::svg, "y", QString())));
// create matrix to transform original path data into desired size and position
QTransform viewMatrix;
viewMatrix.translate(-viewBox.left(), -viewBox.top());
viewMatrix.scale(size.width() / viewBox.width(), size.height() / viewBox.height());
viewMatrix.translate(pos.x(), pos.y());
// transform the path data
map(viewMatrix);
}
}
QString QTikzPicturePrivate::toTikzPath(const QRectF & rect) const
{
if (rect.isEmpty()) return QString();
const QString path = toCoord(rect.topLeft()) + " rectangle "
+ toCoord(rect.bottomRight());
return path;
}
Indices PixelStreamUpdater::computeVisibleSet(const QRectF& visibleTilesArea,
const uint lod,
const uint channel) const
{
Q_UNUSED(lod);
if (!_frameLeftOrMono || visibleTilesArea.isEmpty())
return Indices{};
return _processorLeft->computeVisibleSet(visibleTilesArea, channel);
}
void Canvas::select(QRectF & rect)
{
if (rect.isEmpty()) {
m_found = m_rtree.contains(rect.topLeft());
} else {
m_found = m_rtree.intersects(rect);
}
update();
}
// Drawing Routines
void BitmapImage::draw(GraphicsContext* ctxt, const FloatRect& dst,
const FloatRect& src, ColorSpace styleColorSpace, CompositeOperator op)
{
QRectF normalizedDst = dst.normalized();
QRectF normalizedSrc = src.normalized();
startAnimation();
if (normalizedSrc.isEmpty() || normalizedDst.isEmpty())
return;
QPixmap* image = nativeImageForCurrentFrame();
if (!image)
return;
if (mayFillWithSolidColor()) {
fillWithSolidColor(ctxt, normalizedDst, solidColor(), styleColorSpace, op);
return;
}
#if ENABLE(IMAGE_DECODER_DOWN_SAMPLING)
normalizedSrc = adjustSourceRectForDownSampling(normalizedSrc, image->size());
#endif
CompositeOperator previousOperator = ctxt->compositeOperation();
ctxt->setCompositeOperation(!image->hasAlpha() && op == CompositeSourceOver ? CompositeCopy : op);
if (ctxt->hasShadow()) {
ShadowBlur* shadow = ctxt->shadowBlur();
GraphicsContext* shadowContext = shadow->beginShadowLayer(ctxt, normalizedDst);
if (shadowContext) {
QPainter* shadowPainter = shadowContext->platformContext();
shadowPainter->drawPixmap(normalizedDst, *image, normalizedSrc);
shadow->endShadowLayer(ctxt);
}
}
ctxt->platformContext()->drawPixmap(normalizedDst, *image, normalizedSrc);
ctxt->setCompositeOperation(previousOperator);
if (imageObserver())
imageObserver()->didDraw(this);
}
bool KoEnhancedPathShape::loadOdf( const KoXmlElement & element, KoShapeLoadingContext &context )
{
reset();
KoXmlElement child;
forEachElement( child, element )
{
if( child.localName() == "enhanced-geometry" && child.namespaceURI() == KoXmlNS::draw )
{
// load the viewbox
QRectF viewBox = loadOdfViewbox( child );
if( ! viewBox.isEmpty() )
m_viewBox = viewBox;
// load the modifiers
QString modifiers = child.attributeNS( KoXmlNS::draw, "modifiers", "" );
if( ! modifiers.isEmpty() )
{
addModifiers( modifiers );
}
KoXmlElement grandChild;
forEachElement( grandChild, child )
{
if( grandChild.namespaceURI() != KoXmlNS::draw )
continue;
if( grandChild.localName() == "equation" )
{
QString name = grandChild.attributeNS( KoXmlNS::draw, "name" );
QString formula = grandChild.attributeNS( KoXmlNS::draw, "formula" );
addFormula( name, formula );
}
else if( grandChild.localName() == "handle" )
{
KoEnhancedPathHandle * handle = new KoEnhancedPathHandle( this );
if( handle->loadOdf( grandChild ) )
{
m_enhancedHandles.append( handle );
evaluateHandles();
}
else
delete handle;
}
}
// load the enhanced path data
QString path = child.attributeNS( KoXmlNS::draw, "enhanced-path", "" );
#ifndef NWORKAROUND_ODF_BUGS
KoOdfWorkaround::fixEnhancedPath(path, child, context);
#endif
if ( !path.isEmpty() ) {
parsePathData( path );
}
}
}
void OrthogonalRenderer::drawTileSelection(QPainter *painter,
const QRegion ®ion,
const QColor &color,
const QRectF &exposed) const
{
foreach (const QRect &r, region.rects()) {
const QRectF toFill = QRectF(boundingRect(r)).intersected(exposed);
if (!toFill.isEmpty())
painter->fillRect(toFill, color);
}
}
void MPlainWindow::drawBackground(QPainter *painter, const QRectF &rect)
{
if (not host || rect.isEmpty()) {
return;
}
const QPixmap bg(host->background());
if (not bg.isNull()) {
painter->drawPixmap(rect, bg, rect);
}
}
QRectF GfxBlockItem::generousChildrenBounds() const {
QRectF r;
foreach (Item *i, allChildren())
if (!i->excludeFromNet())
r |= i->mapRectToParent(i->netBounds());
if (r.isEmpty())
return r;
r.setTop(r.top()-style().real("gfx-block-vmargins"));
r.setBottom(r.bottom()+style().real("gfx-block-vmargins"));
return r;
}
void ImageLayer::geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry)
{
if (newGeometry.isEmpty() || !isComponentComplete())
return;
m_geometryChanged = true;
QQuickItem::update();
//XXX when calling it we get some dirty :/
Layer::geometryChanged(newGeometry, oldGeometry);
}
// DkRotatingRect --------------------------------------------------------------------
DkRotatingRect::DkRotatingRect(QRectF rect) {
if (rect.isEmpty()) {
for (int idx = 0; idx < 4; idx++)
this->rect.push_back(QPointF());
}
else
this->rect = rect;
}
void MapHelperUniversal::move(const QRectF &rgn)
{
Q_D(MapHelperUniversal);
if (d->states.testFlag(stMove))
return;
MapSubHelperMove *sub = new MapSubHelperMove(d->map);
d->addSubhelper(sub);
if (!rgn.isEmpty())
sub->initData(rgn.normalized());
}
Indices MovieUpdater::computeVisibleSet(const QRectF& visibleTilesArea,
const uint lod,
const uint channel) const
{
Q_UNUSED(lod);
Q_UNUSED(channel);
if (!_ffmpegMovie || visibleTilesArea.isEmpty())
return Indices();
return {0};
}
void QtCamRoi::setRegionOfInterest(const QRectF& roi) {
if (!d_ptr->dev || !d_ptr->dev->viewfinder()) {
return;
}
QSizeF vf = d_ptr->dev->viewfinder()->videoResolution();
if (vf.isEmpty()) {
return;
}
int frameWidth = vf.width();
int frameHeight = vf.height();
int x = roi.x() * frameWidth;
int y = roi.y() * frameHeight;
int width = roi.width() * frameWidth;
int height = roi.height() * frameHeight;
// if we have an empty roi then we reset:
int priority = roi.isEmpty() ? 0 : 1;
GstStructure *region = gst_structure_new("region0",
"region-x", G_TYPE_UINT, x,
"region-y", G_TYPE_UINT, y,
"region-w", G_TYPE_UINT, width,
"region-h", G_TYPE_UINT, height,
"region-priority", G_TYPE_UINT, priority,
"region-id", G_TYPE_UINT, 0,
NULL);
GValue regionValue = G_VALUE_INIT;
GValue regionList = G_VALUE_INIT;
g_value_init(®ionValue, GST_TYPE_STRUCTURE);
g_value_init(®ionList, GST_TYPE_LIST);
gst_value_set_structure(®ionValue, region);
gst_value_list_append_value(®ionList, ®ionValue);
GstStructure *s = gst_structure_new("regions-of-interest",
"frame-width", G_TYPE_UINT, frameWidth,
"frame-height", G_TYPE_UINT, frameHeight,
NULL);
gst_structure_set_value(s, "regions", ®ionList);
GstEvent *event = gst_event_new_custom(GST_EVENT_CUSTOM_UPSTREAM, s);
gst_structure_free(region);
g_value_unset(®ionValue);
g_value_unset(®ionList);
if (!d_ptr->sendEventToSource(event)) {
qWarning() << "Failed to send ROI event";
}
}
void SVG::render(const QRectF& texCoords)
{
// get on-screen and full rectangle corresponding to the window in pixel units
const QRectF screenRect = renderContext_->getGLWindow()->getProjectedPixelRect(true);
const QRectF fullRect = renderContext_->getGLWindow()->getProjectedPixelRect(false); // maps to [tX, tY, tW, tH]
// If we're not visible or we don't have a valid SVG, we're done.
if(screenRect.isEmpty() || !svgRenderer_.isValid())
{
textureData_.erase(renderContext_->getActiveGLWindow()->getTileIndex());
return;
}
// Get the texture for the current GLWindow
SVGTextureData& textureData = textureData_[renderContext_->getActiveGLWindow()->getTileIndex()];
const QRectF textureRect = computeTextureRect(screenRect, fullRect, texCoords);
const QSize textureSize(round(screenRect.width()), round(screenRect.height()));
const bool recreateTextureFbo = !textureData.fbo || textureData.fbo->size() != textureSize;
if( recreateTextureFbo || textureRect != textureData.region )
{
if ( recreateTextureFbo )
{
textureData.fbo.reset( new QGLFramebufferObject( textureSize ));
}
renderToTexture(textureRect, textureData.fbo);
// keep rendered texture information so we know when to rerender
// this works great when the SVG is only rendered once per GLWindow
// however, it will rerender every time otherwise, for example if the zoom context is shown
textureData.region = textureRect;
}
assert(textureData.fbo);
// figure out what visible region is for screenRect, a subregion of [0, 0, 1, 1]
const float xp = (screenRect.x() - fullRect.x()) / fullRect.width();
const float yp = (screenRect.y() - fullRect.y()) / fullRect.height();
const float wp = screenRect.width() / fullRect.width();
const float hp = screenRect.height() / fullRect.height();
// Render the (scaled) unit textured quad
glPushMatrix();
glTranslatef(xp, yp, 0);
glScalef(wp, hp, 1.f);
drawUnitTexturedQuad(textureData.fbo->texture());
glPopMatrix();
}
void QBlittablePixmapData::markRasterOverlayImpl(const QRectF &rect)
{
if (!showRasterOverlay)
return;
QRectF transformationRect = clipAndTransformRect(rect);
if(!transformationRect.isEmpty()) {
QPainter p(overlay());
p.setBrush(m_overlayColor);
p.setCompositionMode(QPainter::CompositionMode_Source);
p.fillRect(transformationRect,QBrush(m_overlayColor));
}
}
void QPdfEngine::drawImage(const QRectF &rectangle, const QImage &image, const QRectF &sr, Qt::ImageConversionFlags)
{
if (sr.isEmpty() || rectangle.isEmpty() || image.isNull())
return;
Q_D(QPdfEngine);
QRect sourceRect = sr.toRect();
QImage im = sourceRect != image.rect() ? image.copy(sourceRect) : image;
bool bitmap = true;
const int object = d->addImage(im, &bitmap, im.cacheKey());
if (object < 0)
return;
*d->currentPage << "q\n/GSa gs\n";
*d->currentPage
<< QPdf::generateMatrix(QTransform(rectangle.width() / sr.width(), 0, 0, rectangle.height() / sr.height(),
rectangle.x(), rectangle.y()) * (d->simplePen ? QTransform() : d->stroker.matrix));
setBrush();
d->currentPage->streamImage(im.width(), im.height(), object);
*d->currentPage << "Q\n";
}
// Drawing Routines
void BitmapImage::draw(GraphicsContext* ctxt, const FloatRect& dst,
const FloatRect& src, ColorSpace styleColorSpace, CompositeOperator op)
{
QRectF normalizedDst = dst.normalized();
QRectF normalizedSrc = src.normalized();
startAnimation();
if (normalizedSrc.isEmpty() || normalizedDst.isEmpty())
return;
QPixmap* image = nativeImageForCurrentFrame();
if (!image)
return;
if (mayFillWithSolidColor()) {
fillWithSolidColor(ctxt, normalizedDst, solidColor(), styleColorSpace, op);
return;
}
CompositeOperator previousOperator = ctxt->compositeOperation();
ctxt->setCompositeOperation(!image->hasAlpha() && op == CompositeSourceOver ? CompositeCopy : op);
ContextShadow* shadow = ctxt->contextShadow();
if (shadow->m_type != ContextShadow::NoShadow) {
QPainter* shadowPainter = shadow->beginShadowLayer(ctxt, normalizedDst);
if (shadowPainter) {
shadowPainter->setOpacity(static_cast<qreal>(shadow->m_color.alpha()) / 255);
shadowPainter->drawPixmap(normalizedDst, *image, normalizedSrc);
shadow->endShadowLayer(ctxt);
}
}
ctxt->platformContext()->drawPixmap(normalizedDst, *image, normalizedSrc);
ctxt->setCompositeOperation(previousOperator);
if (imageObserver())
imageObserver()->didDraw(this);
}
void NumberPiece::draw(QPainter &painter, const QRectF &rect)
{
if (rect.isEmpty())
return;
if (rect.size() != pixmap.size()) {
pixmap = QPixmap(rect.size().toSize());
init();
}
painter.setOpacity(1.0);
painter.drawPixmap(rect.topLeft(), pixmap);
}
QRectF KoShapeLayer::boundingRect() const
{
QRectF bb;
Q_FOREACH (KoShape* shape, shapes()) {
if (bb.isEmpty())
bb = shape->boundingRect();
else
bb = bb.united(shape->boundingRect());
}
return bb;
}
QT_BEGIN_NAMESPACE
static void drawTexture(const QRectF &rect, GLuint tex_id, const QSize &texSize, const QRectF &br)
{
#if !defined(QT_OPENGL_ES_2)
QGLContext *ctx = const_cast<QGLContext *>(QGLContext::currentContext());
#endif
const GLenum target = GL_TEXTURE_2D;
QRectF src = br.isEmpty()
? QRectF(QPointF(), texSize)
: QRectF(QPointF(br.x(), texSize.height() - br.bottom()), br.size());
if (target == GL_TEXTURE_2D) {
qreal width = texSize.width();
qreal height = texSize.height();
src.setLeft(src.left() / width);
src.setRight(src.right() / width);
src.setTop(src.top() / height);
src.setBottom(src.bottom() / height);
}
const GLfloat tx1 = src.left();
const GLfloat tx2 = src.right();
const GLfloat ty1 = src.top();
const GLfloat ty2 = src.bottom();
GLfloat texCoordArray[4*2] = {
tx1, ty2, tx2, ty2, tx2, ty1, tx1, ty1
};
GLfloat vertexArray[4*2];
vertexArray[0] = rect.left(); vertexArray[1] = rect.top();
vertexArray[2] = rect.right(); vertexArray[3] = rect.top();
vertexArray[4] = rect.right(); vertexArray[5] = rect.bottom();
vertexArray[6] = rect.left(); vertexArray[7] = rect.bottom();
glVertexAttribPointer(QT_VERTEX_COORDS_ATTR, 2, GL_FLOAT, GL_FALSE, 0, vertexArray);
glVertexAttribPointer(QT_TEXTURE_COORDS_ATTR, 2, GL_FLOAT, GL_FALSE, 0, texCoordArray);
glBindTexture(target, tex_id);
glEnableVertexAttribArray(QT_VERTEX_COORDS_ATTR);
glEnableVertexAttribArray(QT_TEXTURE_COORDS_ATTR);
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
glDisableVertexAttribArray(QT_VERTEX_COORDS_ATTR);
glDisableVertexAttribArray(QT_TEXTURE_COORDS_ATTR);
glBindTexture(target, 0);
}
