Merge branch '4.7' of scm.dev.nokia.troll.no:qt/oslo-staging-2 into 4.7-integration

* '4.7' of scm.dev.nokia.troll.no:qt/oslo-staging-2:
  tst_qcompleter.cpp: fix test on mac.
  Fixed autotest that was missing focus on Windows
  QGraphicsLayoutItem - user set sizes should always override, even if there's a constraint
  QGridLayoutEngine - Rework height-for-width support so that row/col spanning works
  Revert "Revert "Fix (implement!) hfw/wfh in QGridLayoutEngine""
  Adjust the parent index for the itemsMoved call.
  Correctly handle both 16bit and 32bit live pixmaps in meego graphics system.
  Correctly remove the egl alpha surface flags in meego graphics system.
  Proper dither & proper alpha checking.
  In meego graphics system, use always 16bit textures.
  QCompleter: do not auto complete when directory is changed.
  tst_qcompleter: Add a test for QFileSystemModel

3 files changed, 55 insertions, 13 deletions

diff --git a/src/plugins/graphicssystems/meego/qmeegographicssystem.cpp b/src/plugins/graphicssystems/meego/qmeegographicssystem.cpp
index f8b228c..27e728a 100644
--- a/src/plugins/graphicssystems/meego/qmeegographicssystem.cpp
+++ b/src/plugins/graphicssystems/meego/qmeegographicssystem.cpp
@@ -275,7 +275,7 @@ bool QMeeGoGraphicsSystem::unlockLiveTexture(Qt::HANDLE h)
     }
 }
 
-void QMeeGoGraphicsSystem::queryLiveTexture(Qt::HANDLE h, void **data, int *pitch)
+void QMeeGoGraphicsSystem::queryLiveTexture(Qt::HANDLE h, void **data, int *pitch, QImage::Format *f)
 {
     // FIXME Only allow this on locked surfaces
     if (! liveTexturePixmaps.contains(h)) {
@@ -289,6 +289,14 @@ void QMeeGoGraphicsSystem::queryLiveTexture(Qt::HANDLE h, void **data, int *pitc
     EGLSurface surface = getSurfaceForLiveTexturePixmap(liveTexturePixmaps.value(h));
     eglQuerySurface(QEgl::display(), surface, EGL_BITMAP_POINTER_KHR, (EGLint*) data);
     eglQuerySurface(QEgl::display(), surface, EGL_BITMAP_PITCH_KHR, (EGLint*) pitch);
+
+    // Ok, here we know we just support those two formats. Real solution would be:
+    // in liveTexturePixmaps store a small structure containing the pixmap and the
+    // original Qt format.
+    if (liveTexturePixmaps.value(h)->depth() > 16)
+        *f = QImage::Format_ARGB32_Premultiplied;
+    else
+        *f = QImage::Format_RGB16;
 }
 
 Qt::HANDLE QMeeGoGraphicsSystem::liveTextureToEGLImage(Qt::HANDLE h)
@@ -363,7 +371,9 @@ EGLSurface QMeeGoGraphicsSystem::getSurfaceForLiveTexturePixmap(QPixmap *pixmap)
         pixmapData->gl_surface = (void*)QEgl::createSurface(pixmap, config);
         
         if (hasAlpha)
-            pixmapData->flags = pixmapData->flags | QX11PixmapData::GlSurfaceCreatedWithAlpha;
+            pixmapData->flags |= QX11PixmapData::GlSurfaceCreatedWithAlpha;
+        else
+            pixmapData->flags &= ~QX11PixmapData::GlSurfaceCreatedWithAlpha;
             
         if (pixmapData->gl_surface == (void*)EGL_NO_SURFACE)
             return NULL;
@@ -439,9 +449,9 @@ bool qt_meego_live_texture_unlock(Qt::HANDLE h)
     return QMeeGoGraphicsSystem::unlockLiveTexture(h);
 }
 
-void qt_meego_live_texture_query(Qt::HANDLE h, void **data, int *pitch)
+void qt_meego_live_texture_query(Qt::HANDLE h, void **data, int *pitch, QImage::Format *f)
 {
-    return QMeeGoGraphicsSystem::queryLiveTexture(h, data, pitch);
+    return QMeeGoGraphicsSystem::queryLiveTexture(h, data, pitch, f);
 }
 
 Qt::HANDLE qt_meego_live_texture_to_egl_image(Qt::HANDLE h)
diff --git a/src/plugins/graphicssystems/meego/qmeegographicssystem.h b/src/plugins/graphicssystems/meego/qmeegographicssystem.h
index 934d32d..fad0db6 100644
--- a/src/plugins/graphicssystems/meego/qmeegographicssystem.h
+++ b/src/plugins/graphicssystems/meego/qmeegographicssystem.h
@@ -71,7 +71,7 @@ public:
     static void destroyLiveTexture(Qt::HANDLE h);
     static bool lockLiveTexture(Qt::HANDLE h);
     static bool unlockLiveTexture(Qt::HANDLE h);
-    static void queryLiveTexture(Qt::HANDLE h, void **data, int *pitch);
+    static void queryLiveTexture(Qt::HANDLE h, void **data, int *pitch, QImage::Format *format);
     static Qt::HANDLE liveTextureToEGLImage(Qt::HANDLE h);
 
 private:
@@ -99,7 +99,7 @@ extern "C" {
     Q_DECL_EXPORT void m_live_texture_destroy(Qt::HANDLE h);
     Q_DECL_EXPORT bool m_live_texture_lock(Qt::HANDLE h);
     Q_DECL_EXPORT bool m_live_texture_unlock(Qt::HANDLE h);
-    Q_DECL_EXPORT void m_live_texture_query(Qt::HANDLE h, void **data, int *pitch);
+    Q_DECL_EXPORT void m_live_texture_query(Qt::HANDLE h, void **data, int *pitch, QImage::Format *f);
     Q_DECL_EXPORT Qt::HANDLE m_live_texture_to_egl_image(Qt::HANDLE h);
 }
 
diff --git a/src/plugins/graphicssystems/meego/qmeegopixmapdata.cpp b/src/plugins/graphicssystems/meego/qmeegopixmapdata.cpp
index 84fc593..5473d09 100644
--- a/src/plugins/graphicssystems/meego/qmeegopixmapdata.cpp
+++ b/src/plugins/graphicssystems/meego/qmeegopixmapdata.cpp
@@ -51,6 +51,24 @@ static EGLint preserved_image_attribs[] = { EGL_IMAGE_PRESERVED_KHR, EGL_TRUE, E
 
 QHash <void*, QMeeGoImageInfo*> QMeeGoPixmapData::sharedImagesMap;
 
+// This helper method converts (in place) a QImage::Format_ARGB4444_Premultiplied to 
+// GL-friendly Format_RGBA4444_Premultiplied. Just swaps the bits around really.
+static void qARGBA4ToRGBA4(QImage *image)
+{
+    unsigned char *raw = static_cast <unsigned char *> (image->data_ptr()->data);
+    // FIXME image.bytesPerLine() is broken. Returns 512 for 128x128 image while it should
+    // return 256
+    int bytesPerLine = image->width() * 2;
+
+    for (int y = 0; y < image->height(); y++) {
+        for (int x = 0; x < image->width(); x++) {
+            unsigned short *target = (unsigned short *) (raw + (y * bytesPerLine + (x * 2)));
+            // FIXME Oh yeah, that's broken with endianness.
+            *target = (*target << 4) | (* target >> 12);
+        }
+    }
+}
+
 /* Public */
 
 QMeeGoPixmapData::QMeeGoPixmapData() : QGLPixmapData(QPixmapData::PixmapType)
@@ -108,8 +126,6 @@ void QMeeGoPixmapData::fromEGLImage(Qt::HANDLE handle)
     QMeeGoExtensions::eglQueryImageNOK(QEgl::display(), (EGLImageKHR) handle, EGL_HEIGHT, &newHeight);
           
     if (textureIsBound) {
-        // FIXME Remove this ugly hasAlphaChannel check when Qt lands the NoOpaqueCheck flag fix
-        // for QGLPixmapData.
         fromTexture(newTextureId, newWidth, newHeight, true); 
     } else {
         qWarning("Failed to create a texture from an egl image!");
@@ -152,10 +168,9 @@ void QMeeGoPixmapData::fromEGLSharedImage(Qt::HANDLE handle, const QImage &si)
     }
         
     if (textureIsBound) {
-        // FIXME Remove this ugly hasAlphaChannel check when Qt lands the NoOpaqueCheck flag fix
-        // for QGLPixmapData.
         fromTexture(newTextureId, newWidth, newHeight, 
                     (si.hasAlphaChannel() && const_cast<QImage &>(si).data_ptr()->checkForAlphaPixels()));
+        texture()->options &= ~QGLContext::InvertedYBindOption;
         softImage = si;
         QMeeGoPixmapData::registerSharedImage(handle, softImage);
     } else {
@@ -171,15 +186,31 @@ Qt::HANDLE QMeeGoPixmapData::imageToEGLSharedImage(const QImage &image)
     QMeeGoExtensions::ensureInitialized();
 
     glFinish();
-    QGLPixmapData pixmapData(QPixmapData::PixmapType);
-    pixmapData.fromImage(image, 0);
-    GLuint textureId = pixmapData.bind();
+
+    GLuint textureId;
+
+    glGenTextures(1, &textureId);
+    glBindTexture(GL_TEXTURE_2D, textureId);
+    if (image.hasAlphaChannel() && (image.hasAlphaChannel() && const_cast<QImage &>(image).data_ptr()->checkForAlphaPixels())) {
+        QImage convertedImage = image.convertToFormat(QImage::Format_ARGB4444_Premultiplied, Qt::DiffuseAlphaDither | Qt::DiffuseDither | Qt::PreferDither);
+        qARGBA4ToRGBA4(&convertedImage);
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, image.width(), image.height(), 0, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, convertedImage.bits());
+    } else {
+        QImage convertedImage = image.convertToFormat(QImage::Format_RGB16, Qt::DiffuseAlphaDither | Qt::DiffuseDither | Qt::PreferDither);
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, image.width(), image.height(), 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, convertedImage.bits());
+    }
+
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 
     glFinish();
+
+    glBindTexture(GL_TEXTURE_2D, textureId);
     EGLImageKHR eglimage = QEgl::eglCreateImageKHR(QEgl::display(), QEglContext::currentContext(QEgl::OpenGL)->context(),
                                                                                                 EGL_GL_TEXTURE_2D_KHR,
                                                                                                 (EGLClientBuffer) textureId,
                                                                                                 preserved_image_attribs);
+    glDeleteTextures(1, &textureId);
     glFinish();
 
     if (eglimage) {
@@ -195,6 +226,7 @@ Qt::HANDLE QMeeGoPixmapData::imageToEGLSharedImage(const QImage &image)
 
 void QMeeGoPixmapData::updateFromSoftImage()
 {
+    // FIXME That's broken with recent 16bit textures changes.
     m_dirty = true;
     m_source = softImage;
     ensureCreated();