FCL/sf/mw/hb: comparison src/hbcore/image/hbnvgiconimpl

equal deleted inserted replaced

-:11d3954df52a
+:627c4a0fd0e7
 #define EGL_DESTROY_SURFACE(display, surface) \
 if (surface != EGL_NO_SURFACE) { eglDestroySurface(display, surface); }
 #define EGL_DESTROY_CONTEXT(display, context) \
 if (context != EGL_NO_CONTEXT) { eglDestroyContext(display, context); }
 // Constants
 static const int HB_BITS_PER_COLOR =    8;
 HbNvgIconImpl::HbNvgIconImpl(const HbSharedIconInfo &iconData,
-const QString& name,
+const QString &name,
-const QSizeF& keySize,
+const QSizeF &keySize,
 Qt::AspectRatioMode aspectRatioMode,
 QIcon::Mode mode,
 bool mirrored,
 HbRenderingMode renderMode):
 HbIconImpl(iconData,
 name,
 keySize,
 aspectRatioMode,
 mode,
 mirrored,
 renderMode),
 readyToRender(false),
 specialCaseApplied(false),
-nvgEngine(NULL),
+nvgEngine(0),
 eglStates(HbEglStates::global()),
 vgImageRenderer(0),
 pixmapIconRenderer(0)
 {
 eglStates->ref();
 retrieveNvgData();
 }
 EGLSurface currentWriteSurface,
 EGLContext eglContext,
 int width,
 int height,
 bool useGivenContext,
-HbNvgEngine * nvgEngine)
+HbNvgEngine *nvgEngine)
 {
 EGLConfig config;
 if (!eglStates->eglConfig || !useGivenContext) {
 EGLint    numConfigs;
 if (eglChooseConfig(display, attribList, &config, 1, &numConfigs) == EGL_FALSE) {
 return currentPixmap;
 }
 if (currentReadSurface == EGL_NO_SURFACE) {
 //pixmap is called without EGL being initialized
 const EGLint attribList2[] = {
 EGL_WIDTH, width,
 EGL_HEIGHT, height,
 EGL_NONE
 HbNvgEngine localNvgEngine;
 EGLContext newContext = EGL_NO_CONTEXT;
 if (eglContext == EGL_NO_CONTEXT) {
 newContext = eglCreateContext(display, config, EGL_NO_CONTEXT, 0);
 if (newContext == EGL_NO_CONTEXT) {
 EGL_DESTROY_SURFACE(display, dummySurface);
 return currentPixmap;
 }
 }
 if (dummySurface) {
 if (eglMakeCurrent(display, dummySurface, dummySurface,
 newContext) == EGL_FALSE) {
 EGL_DESTROY_SURFACE(display, dummySurface);
 EGL_DESTROY_CONTEXT(display, newContext);
 return currentPixmap;
 }
 surfaceImage = createVGImageFromNVG(display,
 dummySurface,
 dummySurface,
 newContext,
 width,
 true,
 &localNvgEngine);
 }
 if (surfaceImage == VG_INVALID_HANDLE) {
 EGL_DESTROY_SURFACE(display, dummySurface);
 EGL_DESTROY_CONTEXT(display, newContext);
 return currentPixmap;
 }
 vgFinish();
 QImage image;
 image = QImage(width, height, QImage::Format_ARGB32_Premultiplied);
 vgGetImageSubData(surfaceImage, image.bits(), image.bytesPerLine(),
 VG_sARGB_8888_PRE, 0, 0, width, height);
 eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
 } else {
 eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
 prevEGLState.restore();
 image = QImage(width, height, QImage::Format_ARGB32_Premultiplied);
 vgGetImageSubData(surfaceImage, image.bits(), image.bytesPerLine(),
 VG_sARGB_8888_PRE, 0, 0, width, height);
 }
 vgDestroyImage(surfaceImage);
 EGL_DESTROY_SURFACE(display, dummySurface);
 EGL_DESTROY_CONTEXT(display, newContext);
 currentPixmap = QPixmap::fromImage(image);
 return currentPixmap;
 }
-HbNvgEngine::HbNvgErrorType HbNvgIconImpl::drawNVGIcon(const QSize & size, HbNvgEngine & nvgEngine)
+HbNvgEngine::HbNvgErrorType HbNvgIconImpl::drawNVGIcon(const QSize &size, HbNvgEngine &nvgEngine)
 {
 VGint                   mMatrixMode;
 VGfloat                 mImageMatrix[9];
 VGfloat                 mPathMatrix[9];
 }
 void HbNvgIconImpl::retrieveNvgData()
 {
 GET_MEMORY_MANAGER(HbMemoryManager::SharedMemory);
-nvgData  = QByteArray::fromRawData((char*)manager->base() + sharedIconData.nvgData.offset,
+nvgData  = QByteArray::fromRawData((char *)manager->base() + sharedIconData.nvgData.offset,
 sharedIconData.nvgData.dataSize);
 defaultIconSize =
 QSize(sharedIconData.nvgData.defaultWidth, sharedIconData.nvgData.defaultHeight);
 contentSize = QSize(sharedIconData.nvgData.width, sharedIconData.nvgData.height);
 }
-VGImage HbNvgIconImpl::getVgImage(HbIconImpl * impl, QPainter * painter)
+VGImage HbNvgIconImpl::getVgImage(HbIconImpl *impl, QPainter *painter)
 {
-HbNvgIconImpl * nvgImpl = (HbNvgIconImpl*)impl;
+HbNvgIconImpl *nvgImpl = (HbNvgIconImpl *)impl;
 painter->beginNativePainting();
 VGImage vgimage = nvgImpl->createVGImageFromNVG(nvgImpl->eglStates->display,
 nvgImpl->eglStates->currentReadSurface,
 painter->endNativePainting();
 return vgimage;
 }
-void HbNvgIconImpl::paint(QPainter* painter,
+void HbNvgIconImpl::paint(QPainter *painter,
-const QRectF& rect,
+const QRectF &rect,
 Qt::Alignment alignment,
 const QPainterPath &clipPath,
-HbMaskableIconImpl * maskIconData)
+HbMaskableIconImpl *maskIconData)
 {
 #ifdef HB_ICON_CACHE_DEBUG
-qDebug() << "HbNvgIconImpl::paint()-->"<<this->fileName;
+qDebug() << "HbNvgIconImpl::paint()-->" << this->fileName;
 #endif
 QSizeF renderSize = contentSize;
 NvgAspectRatioSettings settings = mapKeyAspectRatioToNvgAspectRatio(aspectRatioMode);
 bool maskApplied = false;
 if (maskIconData && (maskIconData->maskChanged() ||  maskIconData->implData())) {
 maskApplied = true;
 }
-if ((painter->paintEngine()->type() != QPaintEngine::OpenVG) || maskApplied) {
+QPaintEngine *paintEngine = painter->paintEngine();
+if (!paintEngine || paintEngine->type() != QPaintEngine::OpenVG || maskApplied) {
 painter->beginNativePainting();
 pixmap();
 painter->endNativePainting();
 multiPieceIcon || painter->opacity() != 1.0) {
 if (drawRasterizedIcon(painter, topLeft, renderSize, clipPath)) {
 return;
 }
 }
 vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_FASTER);
 drawNVGIcon(painter, topLeft, renderSize, settings);
 }
-void HbNvgIconImpl::drawNVGIcon(QPainter * painter,
+void HbNvgIconImpl::drawNVGIcon(QPainter *painter,
-const QPointF & topLeft,
+const QPointF &topLeft,
-const QSizeF & renderSize,
+const QSizeF &renderSize,
 NvgAspectRatioSettings settings)
 {
 nvgEngine->engine()->setPreserveAspectRatio(settings.nvgAlignStatusAndAspectRatio,
 settings.type);
 nvgEngine->engine()->enableMirroring(mirrored);
 painter->beginNativePainting();
 vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
 vgTranslate(topLeft.x(), topLeft.y());
 nvgEngine->engine()->drawNvg(nvgData, renderSize.toSize());
 painter->endNativePainting();
 }
-bool HbNvgIconImpl::drawRasterizedIcon(QPainter * painter,
+bool HbNvgIconImpl::drawRasterizedIcon(QPainter *painter,
-const QPointF & topLeft,
+const QPointF &topLeft,
-const QSizeF & renderSize,
+const QSizeF &renderSize,
 const QPainterPath &clipPath)
 {
 bool ret = false;
 // need to do a reset if EGL contexts changes/recreated
 if (!eglStates->initialized()) {
 ret = vgImageRenderer->draw(painter, topLeft, clipPath);
 }
 return ret;
 }
-QPointF HbNvgIconImpl::setAlignment(const QRectF& rect,
+QPointF HbNvgIconImpl::setAlignment(const QRectF &rect,
-QSizeF& renderSize,
+QSizeF &renderSize,
 Qt::Alignment alignment)
 {
 QPointF topLeft = rect.topLeft();
 if (alignment & Qt::AlignRight) {
 topLeft.setX(rect.right() - renderSize.width());

changeset 5	627c4a0fd0e7
parent 2	06ff229162e9
child 6	c3690ec91ef8