void QVGPixmapDropShadowFilter::draw(QPainter *painter, const QPointF &dest, const QPixmap &src, const QRectF &srcRect) const { if (src.isNull()) return; if (src.pixmapData()->classId() != QPixmapData::OpenVGClass) { // The pixmap data is not an instance of QVGPixmapData, so fall // back to the default drop shadow filter implementation. QPixmapDropShadowFilter::draw(painter, dest, src, srcRect); return; } QVGPixmapData *pd = static_cast<QVGPixmapData *>(src.pixmapData()); VGImage srcImage = pd->toVGImage(); if (srcImage == VG_INVALID_HANDLE) return; QSize size = pd->size(); VGImage dstImage = QVGImagePool::instance()->createTemporaryImage (VG_A_8, size.width(), size.height(), VG_IMAGE_QUALITY_FASTER, pd); if (dstImage == VG_INVALID_HANDLE) return; // Clamp the radius range. We divide by 2 because the OpenVG blur // is "too blurry" compared to the default raster implementation. VGfloat maxRadius = VGfloat(vgGeti(VG_MAX_GAUSSIAN_STD_DEVIATION)); VGfloat radiusF = VGfloat(blurRadius()) / 2.0f; if (radiusF < 0.001f) radiusF = 0.001f; else if (radiusF > maxRadius) radiusF = maxRadius; // Blur the blackened source image. vgGaussianBlur(dstImage, srcImage, radiusF, radiusF, VG_TILE_PAD); VGImage child = VG_INVALID_HANDLE; QRect srect; if (srcRect.isNull() || (srcRect.topLeft().isNull() && srcRect.size() == size)) { child = dstImage; srect = QRect(0, 0, size.width(), size.height()); } else { srect = srcRect.toRect(); child = vgChildImage(dstImage, srect.x(), srect.y(), srect.width(), srect.height()); } qt_vg_drawVGImageStencil(painter, dest + offset(), child, color()); if(child != dstImage) vgDestroyImage(child); QVGImagePool::instance()->releaseImage(0, dstImage); // Now draw the actual pixmap over the top. painter->drawPixmap(dest, src, srect); }
void QS60PaintEngine::drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr) { if (pm.pixmapData()->classId() == QPixmapData::RasterClass) { QS60PixmapData *srcData = static_cast<QS60PixmapData *>(pm.pixmapData()); srcData->beginDataAccess(); QRasterPaintEngine::drawPixmap(r, pm, sr); srcData->endDataAccess(); } else { QRasterPaintEngine::drawPixmap(r, pm, sr); } }
void QVGPixmapBlurFilter::draw(QPainter *painter, const QPointF &dest, const QPixmap &src, const QRectF &srcRect) const { if (src.isNull()) return; if (src.pixmapData()->classId() != QPixmapData::OpenVGClass) { // The pixmap data is not an instance of QVGPixmapData, so fall // back to the default blur filter implementation. QPixmapBlurFilter::draw(painter, dest, src, srcRect); return; } QVGPixmapData *pd = static_cast<QVGPixmapData *>(src.pixmapData()); VGImage srcImage = pd->toVGImage(); if (srcImage == VG_INVALID_HANDLE) return; QSize size = pd->size(); VGImage dstImage = QVGImagePool::instance()->createTemporaryImage (VG_sARGB_8888_PRE, size.width(), size.height(), VG_IMAGE_QUALITY_FASTER, pd); if (dstImage == VG_INVALID_HANDLE) return; // Clamp the radius range. We divide by 2 because the OpenVG blur // is "too blurry" compared to the default raster implementation. VGfloat maxRadius = VGfloat(vgGeti(VG_MAX_GAUSSIAN_STD_DEVIATION)); VGfloat radiusF = VGfloat(radius()) / 2.0f; if (radiusF < 0.001f) radiusF = 0.001f; else if (radiusF > maxRadius) radiusF = maxRadius; vgGaussianBlur(dstImage, srcImage, radiusF, radiusF, VG_TILE_PAD); VGImage child = VG_INVALID_HANDLE; if (srcRect.isNull() || (srcRect.topLeft().isNull() && srcRect.size() == size)) { child = dstImage; } else { QRect src = srcRect.toRect(); child = vgChildImage(dstImage, src.x(), src.y(), src.width(), src.height()); } qt_vg_drawVGImage(painter, dest, child); if(child != dstImage) vgDestroyImage(child); QVGImagePool::instance()->releaseImage(0, dstImage); }
void QS60PaintEngine::drawTiledPixmap(const QRectF &r, const QPixmap &pm, const QPointF &sr) { QS60PixmapData *srcData = static_cast<QS60PixmapData *>(pm.pixmapData()); srcData->beginDataAccess(); QRasterPaintEngine::drawTiledPixmap(r, pm, sr); srcData->endDataAccess(); }
void QS60PaintEngine::drawPixmap(const QPointF &p, const QPixmap &pm) { QS60PixmapData *srcData = static_cast<QS60PixmapData *>(pm.pixmapData()); srcData->beginDataAccess(); QRasterPaintEngine::drawPixmap(p, pm); srcData->endDataAccess(); }
void QDirectFbBlitter::drawPixmap(const QRectF &rect, const QPixmap &pixmap, const QRectF &srcRect) { QPixmapData *data = pixmap.pixmapData(); Q_ASSERT(data->width() && data->height()); Q_ASSERT(data->classId() == QPixmapData::BlitterClass); QBlittablePixmapData *blitPm = static_cast<QBlittablePixmapData*>(data); QDirectFbBlitter *dfbBlitter = static_cast<QDirectFbBlitter *>(blitPm->blittable()); dfbBlitter->unlock(); IDirectFBSurface *s = dfbBlitter->m_surface.data(); DFBSurfaceBlittingFlags blittingFlags = DSBLIT_NOFX; DFBSurfacePorterDuffRule porterDuff = DSPD_SRC; if (pixmap.hasAlpha()) { blittingFlags = DSBLIT_BLEND_ALPHACHANNEL; porterDuff = DSPD_SRC_OVER; } m_surface->SetBlittingFlags(m_surface.data(), DFBSurfaceBlittingFlags(blittingFlags)); m_surface->SetPorterDuff(m_surface.data(), porterDuff); m_surface->SetDstBlendFunction(m_surface.data(), DSBF_INVSRCALPHA); const DFBRectangle sRect = { srcRect.x(), srcRect.y(), srcRect.width(), srcRect.height() }; DFBResult result; if (rect.width() == srcRect.width() && rect.height() == srcRect.height()) result = m_surface->Blit(m_surface.data(), s, &sRect, rect.x(), rect.y()); else { const DFBRectangle dRect = { rect.x(), rect.y(), rect.width(), rect.height() }; result = m_surface->StretchBlit(m_surface.data(), s, &sRect, &dRect); } if (result != DFB_OK) DirectFBError("QDirectFBBlitter::drawPixmap()", result); }
void QDirectFBCursor::changeCursor(QCursor *cursor, QWidget *) { int xSpot; int ySpot; QPixmap map; if (cursor->shape() != Qt::BitmapCursor) { m_image->set(cursor->shape()); xSpot = m_image->hotspot().x(); ySpot = m_image->hotspot().y(); QImage *i = m_image->image(); map = QPixmap::fromImage(*i); } else { QPoint point = cursor->hotSpot(); xSpot = point.x(); ySpot = point.y(); map = cursor->pixmap(); } DFBResult res; IDirectFBDisplayLayer *layer = toDfbLayer(screen); IDirectFBSurface* surface(QDirectFbConvenience::dfbSurfaceForPlatformPixmap(map.pixmapData())); res = layer->SetCooperativeLevel(layer, DLSCL_ADMINISTRATIVE); if (res != DFB_OK) { DirectFBError("Failed to set DLSCL_ADMINISTRATIVE", res); return; } layer->SetCursorShape(layer, surface, xSpot, ySpot); layer->SetCooperativeLevel(layer, DLSCL_SHARED); }
void tst_NativeImageHandleProvider::hibernate() { #if defined(Q_OS_SYMBIAN) && !defined(QT_NO_OPENVG) QPixmap tmp(10, 20); if (tmp.pixmapData()->classId() == QPixmapData::OpenVGClass) { BitmapProvider prov; prov.bmp = new CFbsBitmap; QCOMPARE(prov.bmp->Create(TSize(prov.w, prov.h), EColor16MAP), KErrNone); QPixmap pm = pixmapFromNativeImageHandleProvider(&prov); QCOMPARE(prov.refCount, 1); QVGPixmapData *vgpd = static_cast<QVGPixmapData *>(pm.pixmapData()); vgpd->hibernate(); QCOMPARE(prov.refCount, 0); // Calling toVGImage() may cause some warnings as we don't have a gui initialized, // but the only thing we care about here is get() being called. vgpd->toVGImage(); QCOMPARE(prov.refCount, 1); pm = QPixmap(); QCOMPARE(prov.refCount, 0); delete prov.bmp; } else { QSKIP("Not openvg", SkipSingle); } #else QSKIP("Not applicable", SkipSingle); #endif }
bool canBlitterDrawPixmapOpacity(const QPixmap &pm) const { if (pm.pixmapData()->classId() != QPixmapData::BlitterClass) return false; return checkStateAgainstMask(capabillitiesState, opacityPixmapMask); }
/* \internal Returns the VGImage that is storing the contents of \a pixmap. Returns VG_INVALID_HANDLE if \a pixmap is not owned by the OpenVG graphics system or \a pixmap is invalid. This function is typically used to access the backing store for a pixmap when executing raw OpenVG calls. It must only be used when a QPainter is active and the OpenVG paint engine is in use by the QPainter. \sa {QtOpenVG Module} */ Q_OPENVG_EXPORT VGImage qPixmapToVGImage(const QPixmap& pixmap) { QPixmapData *pd = pixmap.pixmapData(); if (!pd) return VG_INVALID_HANDLE; // null QPixmap if (pd->classId() == QPixmapData::OpenVGClass) { QVGPixmapData *vgpd = static_cast<QVGPixmapData *>(pd); if (vgpd->isValid()) return vgpd->toVGImage(); } return VG_INVALID_HANDLE; }
void FusionForeverWidget::DrawSection(Section_ptr section, std::string name, std::vector<std::pair<std::string, QPixmap*> >& icons) { if(section) { float radius = section->GetRadius(); Camera::Instance().SetSmallestDimension(40); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); Camera::Instance().SetupCamera(); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); //Draw Section section->DeathTick(); section->SetOutlineColor(GLColor(0,0,0)); section->DrawSelf(); glFlush(); QImage icon = grabFrameBuffer(); if(height() > width()) { int top = (height() - width()) / 2; QImage icon2 = icon.copy(0, top, width(), width()); QPixmap pm = QPixmap::fromImage(icon2); icons.push_back(std::pair<std::string, QPixmap*>(name, new QPixmap(pm.pixmapData()))); } else { int left = (width() - height()) / 2; QImage icon2 = icon.copy(left, 0, height(), height()); QPixmap pm = QPixmap::fromImage(icon2); icons.push_back(std::pair<std::string, QPixmap*>(name, new QPixmap(pm.pixmapData()))); } delete section; } }
void QVolatileImagePaintEngine::drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr) { #ifdef Q_OS_SYMBIAN QVolatileImage img = pm.pixmapData()->toVolatileImage(); if (!img.isNull()) { img.beginDataAccess(); QRasterPaintEngine::drawImage(r, img.constImageRef(), sr); img.endDataAccess(true); } else { QRasterPaintEngine::drawPixmap(r, pm, sr); } #else QRasterPaintEngine::drawPixmap(r, pm, sr); #endif }
bool canBlitterDrawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr) const { if (pm.pixmapData()->classId() != QPixmapData::BlitterClass) return false; if (checkStateAgainstMask(capabillitiesState, drawPixmapMask)) { if (m_capabilities & (QBlittable::SourceOverPixmapCapability | QBlittable::SourceOverScaledPixmapCapability)) { if (r.size() != sr.size()) return m_capabilities & QBlittable::SourceOverScaledPixmapCapability; else return m_capabilities & QBlittable::SourceOverPixmapCapability; } if ((m_capabilities & QBlittable::SourcePixmapCapability) && r.size() == sr.size() && !pm.hasAlphaChannel()) return m_capabilities & QBlittable::SourcePixmapCapability; } return false; }
void QVolatileImagePaintEngine::drawPixmap(const QPointF &p, const QPixmap &pm) { #ifdef Q_OS_SYMBIAN QVolatileImage img = pm.pixmapData()->toVolatileImage(); if (!img.isNull()) { img.beginDataAccess(); // imageRef() would detach and since we received the QVolatileImage from // toVolatileImage() by value, it would cause a copy which would ruin // our goal. So use constImageRef() instead. QRasterPaintEngine::drawImage(p, img.constImageRef()); img.endDataAccess(true); } else { QRasterPaintEngine::drawPixmap(p, pm); } #else QRasterPaintEngine::drawPixmap(p, pm); #endif }
void QDirectFbBlitter::drawPixmapOpacity(const QRectF &rect, const QPixmap &pixmap, const QRectF &subrect, QPainter::CompositionMode cmode, qreal opacity) { QRect sQRect = subrect.toRect(); QRect dQRect = rect.toRect(); DFBRectangle sRect = { sQRect.x(), sQRect.y(), sQRect.width(), sQRect.height() }; DFBRectangle dRect = { dQRect.x(), dQRect.y(), dQRect.width(), dQRect.height() }; DFBResult result; // skip if dst too small if ((dRect.w <= 0) || (dRect.h <= 0)) return; // correct roundings if needed if (sRect.w <= 0) sRect.w = 1; if (sRect.h <= 0) sRect.h = 1; QBlittablePixmapData *blitPm = static_cast<QBlittablePixmapData*>(pixmap.pixmapData()); QDirectFbBlitter *dfbBlitter = static_cast<QDirectFbBlitter *>(blitPm->blittable()); dfbBlitter->unlock(); IDirectFBSurface *s = dfbBlitter->m_surface.data(); DFBSurfaceBlittingFlags blittingFlags = DFBSurfaceBlittingFlags(DSBLIT_BLEND_ALPHACHANNEL); DFBSurfacePorterDuffRule porterDuff = (cmode == QPainter::CompositionMode_SourceOver) ? DSPD_SRC_OVER : DSPD_SRC; if (opacity != 1.0) { blittingFlags = DFBSurfaceBlittingFlags(blittingFlags | DSBLIT_BLEND_COLORALPHA | (m_premult ? DSBLIT_SRC_PREMULTCOLOR : 0)); m_surface->SetColor(m_surface.data(), 0xff, 0xff, 0xff, (u8) (opacity * 255.0)); } m_surface->SetBlittingFlags(m_surface.data(), DFBSurfaceBlittingFlags(blittingFlags)); m_surface->SetPorterDuff(m_surface.data(), porterDuff); if (cmode == QPainter::CompositionMode_SourceOver) m_surface->SetDstBlendFunction(m_surface.data(), DSBF_INVSRCALPHA); if ((sRect.w == dRect.w) && (sRect.h == dRect.h)) result = m_surface->Blit(m_surface.data(), s, &sRect, dRect.x, dRect.y); else result = m_surface->StretchBlit(m_surface.data(), s, &sRect, &dRect); if (result != DFB_OK) DirectFBError("QDirectFBBlitter::drawPixmapExtended()", result); }
void QVGPixmapConvolutionFilter::draw (QPainter *painter, const QPointF &dest, const QPixmap &src, const QRectF &srcRect) const { if (src.isNull()) return; if (src.pixmapData()->classId() != QPixmapData::OpenVGClass) { // The pixmap data is not an instance of QVGPixmapData, so fall // back to the default convolution filter implementation. QPixmapConvolutionFilter::draw(painter, dest, src, srcRect); return; } QVGPixmapData *pd = static_cast<QVGPixmapData *>(src.pixmapData()); VGImage srcImage = pd->toVGImage(); if (srcImage == VG_INVALID_HANDLE) return; QSize size = pd->size(); VGImage dstImage = QVGImagePool::instance()->createTemporaryImage (VG_sARGB_8888_PRE, size.width(), size.height(), VG_IMAGE_QUALITY_FASTER, pd); if (dstImage == VG_INVALID_HANDLE) return; int kernelWidth = rows(); int kernelHeight = columns(); const qreal *kern = convolutionKernel(); QVarLengthArray<VGshort> kernel; for (int i = 0; i < kernelWidth; ++i) { for (int j = 0; j < kernelHeight; ++j) { kernel.append((VGshort)(kern[j * kernelWidth + i] * 1024.0f)); } } VGfloat values[4]; values[0] = 0.0f; values[1] = 0.0f; values[2] = 0.0f; values[3] = 0.0f; vgSetfv(VG_TILE_FILL_COLOR, 4, values); vgConvolve(dstImage, srcImage, kernelWidth, kernelHeight, 0, 0, kernel.constData(), 1.0f / 1024.0f, 0.0f, VG_TILE_FILL); VGImage child = VG_INVALID_HANDLE; if (srcRect.isNull() || (srcRect.topLeft().isNull() && srcRect.size() == size)) { child = dstImage; } else { QRect src = srcRect.toRect(); child = vgChildImage(dstImage, src.x(), src.y(), src.width(), src.height()); } qt_vg_drawVGImage(painter, dest, child); if(child != dstImage) vgDestroyImage(child); QVGImagePool::instance()->releaseImage(0, dstImage); }
void QVGPixmapColorizeFilter::draw(QPainter *painter, const QPointF &dest, const QPixmap &src, const QRectF &srcRect) const { if (src.isNull()) return; if (src.pixmapData()->classId() != QPixmapData::OpenVGClass) { // The pixmap data is not an instance of QVGPixmapData, so fall // back to the default colorize filter implementation. QPixmapColorizeFilter::draw(painter, dest, src, srcRect); return; } QVGPixmapData *pd = static_cast<QVGPixmapData *>(src.pixmapData()); VGImage srcImage = pd->toVGImage(); if (srcImage == VG_INVALID_HANDLE) return; QSize size = pd->size(); VGImage dstImage = QVGImagePool::instance()->createTemporaryImage (VG_sARGB_8888_PRE, size.width(), size.height(), VG_IMAGE_QUALITY_FASTER, pd); if (dstImage == VG_INVALID_HANDLE) return; // Determine the weights for the matrix from the color and strength. QColor c = color(); VGfloat strength = this->strength(); VGfloat weights[3]; VGfloat invweights[3]; VGfloat alpha = c.alphaF(); weights[0] = c.redF() * alpha; weights[1] = c.greenF() * alpha; weights[2] = c.blueF() * alpha; invweights[0] = (1.0f - weights[0]) * strength; invweights[1] = (1.0f - weights[1]) * strength; invweights[2] = (1.0f - weights[2]) * strength; // Grayscale weights. static const VGfloat redGray = 11.0f / 32.0f; static const VGfloat greenGray = 16.0f / 32.0f; static const VGfloat blueGray = 1.0f - (redGray + greenGray); VGfloat matrix[5][4]; matrix[0][0] = redGray * invweights[0] + (1.0f - strength); matrix[0][1] = redGray * invweights[1]; matrix[0][2] = redGray * invweights[2]; matrix[0][3] = 0.0f; matrix[1][0] = greenGray * invweights[0]; matrix[1][1] = greenGray * invweights[1] + (1.0f - strength); matrix[1][2] = greenGray * invweights[2]; matrix[1][3] = 0.0f; matrix[2][0] = blueGray * invweights[0]; matrix[2][1] = blueGray * invweights[1]; matrix[2][2] = blueGray * invweights[2] + (1.0f - strength); matrix[2][3] = 0.0f; matrix[3][0] = 0.0f; matrix[3][1] = 0.0f; matrix[3][2] = 0.0f; matrix[3][3] = 1.0f; matrix[4][0] = weights[0] * strength; matrix[4][1] = weights[1] * strength; matrix[4][2] = weights[2] * strength; matrix[4][3] = 0.0f; vgColorMatrix(dstImage, srcImage, matrix[0]); VGImage child = VG_INVALID_HANDLE; if (srcRect.isNull() || (srcRect.topLeft().isNull() && srcRect.size() == size)) { child = dstImage; } else { QRect src = srcRect.toRect(); child = vgChildImage(dstImage, src.x(), src.y(), src.width(), src.height()); } qt_vg_drawVGImage(painter, dest, child); if(child != dstImage) vgDestroyImage(child); QVGImagePool::instance()->releaseImage(0, dstImage); }