Merge branch '4.6' of git@scm.dev.nokia.troll.no:qt/qt into 4.6

9 files changed, 115 insertions, 55 deletions

diff --git a/src/corelib/global/qnamespace.qdoc b/src/corelib/global/qnamespace.qdoc
index b7775bd..ab232bf 100644
--- a/src/corelib/global/qnamespace.qdoc
+++ b/src/corelib/global/qnamespace.qdoc
@@ -713,7 +713,13 @@
     \omitvalue Dither_Mask
     \omitvalue AlphaDither_Mask
     \omitvalue DitherMode_Mask
-    \omitvalue NoOpaqueDetection
+
+    \value NoOpaqueDetection Do not check whether the image contains non-opaque
+           pixels. Use this if you know that the image is semi-transparent and
+           you want to avoid the overhead of checking the pixels in the image
+           until a non-opaque pixel is found, or if you want the pixmap to
+           retain an alpha channel for some other reason. If the image has no
+           alpha channel this flag has no effect.
 */
 
 /*! \enum Qt::GUIStyle
diff --git a/src/gui/util/qdesktopservices_win.cpp b/src/gui/util/qdesktopservices_win.cpp
index bf29870..4ecef97 100644
--- a/src/gui/util/qdesktopservices_win.cpp
+++ b/src/gui/util/qdesktopservices_win.cpp
@@ -186,7 +186,11 @@ QString QDesktopServices::storageLocation(StandardLocation type)
 
     switch (type) {
     case DataLocation:
+#if defined Q_WS_WINCE
+        if (SHGetSpecialFolderPath(0, path, CSIDL_APPDATA, FALSE))
+#else
         if (SHGetSpecialFolderPath(0, path, CSIDL_LOCAL_APPDATA, FALSE))
+#endif
             result = QString::fromWCharArray(path);
         if (!QCoreApplication::organizationName().isEmpty())
             result = result + QLatin1String("\\") + QCoreApplication::organizationName();
diff --git a/src/opengl/gl2paintengineex/qgl2pexvertexarray.cpp b/src/opengl/gl2paintengineex/qgl2pexvertexarray.cpp
index 866d1a2..1fe3999 100644
--- a/src/opengl/gl2paintengineex/qgl2pexvertexarray.cpp
+++ b/src/opengl/gl2paintengineex/qgl2pexvertexarray.cpp
@@ -67,7 +67,30 @@ void QGL2PEXVertexArray::addRect(const QRectF &rect)
                 << rect.bottomRight() << rect.bottomLeft() << rect.topLeft();
 }
 
-void QGL2PEXVertexArray::addPath(const QVectorPath &path, GLfloat curveInverseScale)
+void QGL2PEXVertexArray::addClosingLine(int index)
+{
+    if (QPointF(vertexArray.at(index)) != QPointF(vertexArray.last()))
+        vertexArray.add(vertexArray.at(index));
+}
+
+void QGL2PEXVertexArray::addCentroid(const QVectorPath &path, int subPathIndex)
+{
+    const QPointF *const points = reinterpret_cast<const QPointF *>(path.points());
+    const QPainterPath::ElementType *const elements = path.elements();
+
+    QPointF sum = points[subPathIndex];
+    int count = 1;
+
+    for (int i = subPathIndex + 1; i < path.elementCount() && (!elements || elements[i] != QPainterPath::MoveToElement); ++i) {
+        sum += points[i];
+        ++count;
+    }
+
+    const QPointF centroid = sum / qreal(count);
+    vertexArray.add(centroid);
+}
+
+void QGL2PEXVertexArray::addPath(const QVectorPath &path, GLfloat curveInverseScale, bool outline)
 {
     const QPointF* const points = reinterpret_cast<const QPointF*>(path.points());
     const QPainterPath::ElementType* const elements = path.elements();
@@ -78,6 +101,10 @@ void QGL2PEXVertexArray::addPath(const QVectorPath &path, GLfloat curveInverseSc
         boundingRectDirty = false;
     }
 
+    if (!outline)
+        addCentroid(path, 0);
+
+    int lastMoveTo = vertexArray.size();
     vertexArray.add(points[0]); // The first element is always a moveTo
 
     do {
@@ -96,8 +123,14 @@ void QGL2PEXVertexArray::addPath(const QVectorPath &path, GLfloat curveInverseSc
             const QPainterPath::ElementType elementType = elements[i];
             switch (elementType) {
             case QPainterPath::MoveToElement:
+                if (!outline)
+                    addClosingLine(lastMoveTo);
 //                qDebug("element[%d] is a MoveToElement", i);
                 vertexArrayStops.append(vertexArray.size());
+                if (!outline) {
+                    addCentroid(path, i);
+                    lastMoveTo = vertexArray.size();
+                }
                 lineToArray(points[i].x(), points[i].y()); // Add the moveTo as a new vertex
                 break;
             case QPainterPath::LineToElement:
@@ -115,6 +148,8 @@ void QGL2PEXVertexArray::addPath(const QVectorPath &path, GLfloat curveInverseSc
         }
     } while (0);
 
+    if (!outline)
+        addClosingLine(lastMoveTo);
     vertexArrayStops.append(vertexArray.size());
 }
 
diff --git a/src/opengl/gl2paintengineex/qgl2pexvertexarray_p.h b/src/opengl/gl2paintengineex/qgl2pexvertexarray_p.h
index 08ce234..719904f 100644
--- a/src/opengl/gl2paintengineex/qgl2pexvertexarray_p.h
+++ b/src/opengl/gl2paintengineex/qgl2pexvertexarray_p.h
@@ -104,7 +104,7 @@ public:
         boundingRectDirty(true) {}
 
     void addRect(const QRectF &rect);
-    void addPath(const QVectorPath &path, GLfloat curveInverseScale);
+    void addPath(const QVectorPath &path, GLfloat curveInverseScale, bool outline = true);
     void clear();
 
     QGLPoint*        data() {return vertexArray.data();}
@@ -124,6 +124,9 @@ private:
     bool        boundingRectDirty;
 
     inline void curveToArray(const QGLPoint &cp1, const QGLPoint &cp2, const QGLPoint &ep, GLfloat inverseScale);
+
+    void addClosingLine(int index);
+    void addCentroid(const QVectorPath &path, int subPathIndex);
 };
 
 QT_END_NAMESPACE
diff --git a/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp b/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp
index 5875124..ab02c69 100644
--- a/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp
+++ b/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp
@@ -391,7 +391,6 @@ void QGL2PaintEngineExPrivate::setBrush(const QBrush* brush)
 }
 
 
-// Unless this gets used elsewhere, it's probably best to merge it into fillStencilWithVertexArray
 void QGL2PaintEngineExPrivate::useSimpleShader()
 {
     shaderManager->simpleProgram()->enable();
@@ -881,26 +880,36 @@ void QGL2PaintEngineExPrivate::fill(const QVectorPath& path)
              || path.shape() == QVectorPath::ConvexPolygonHint)
     {
         vertexCoordinateArray.clear();
-        vertexCoordinateArray.addPath(path, inverseScale);
+        vertexCoordinateArray.addPath(path, inverseScale, false);
         prepareForDraw(currentBrush->isOpaque());
         drawVertexArrays(vertexCoordinateArray, GL_TRIANGLE_FAN);
     } else {
         // The path is too complicated & needs the stencil technique
         vertexCoordinateArray.clear();
-        vertexCoordinateArray.addPath(path, inverseScale);
+        vertexCoordinateArray.addPath(path, inverseScale, false);
 
         fillStencilWithVertexArray(vertexCoordinateArray, path.hasWindingFill());
 
-        // Stencil the brush onto the dest buffer
-        glStencilFunc(GL_EQUAL, GL_STENCIL_HIGH_BIT, GL_STENCIL_HIGH_BIT); // Pass if stencil buff value != 0
-        glStencilOp(GL_KEEP, GL_ZERO, GL_ZERO);
-        glStencilMask(GL_STENCIL_HIGH_BIT);
+        glStencilMask(0xff);
+        glStencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);
+
+        if (q->state()->clipTestEnabled) {
+            // Pass when high bit is set, replace stencil value with current clip
+            glStencilFunc(GL_NOTEQUAL, q->state()->currentClip, GL_STENCIL_HIGH_BIT);
+        } else if (path.hasWindingFill()) {
+            // Pass when any bit is set, replace stencil value with 0
+            glStencilFunc(GL_NOTEQUAL, 0, 0xff);
+        } else {
+            // Pass when high bit is set, replace stencil value with 0
+            glStencilFunc(GL_NOTEQUAL, 0, GL_STENCIL_HIGH_BIT);
+        }
 
         prepareForDraw(currentBrush->isOpaque());
 
         if (inRenderText)
             prepareDepthRangeForRenderText();
 
+        // Stencil the brush onto the dest buffer
         composite(vertexCoordinateArray.boundingRect());
 
         if (inRenderText)
@@ -916,7 +925,7 @@ void QGL2PaintEngineExPrivate::fill(const QVectorPath& path)
 void QGL2PaintEngineExPrivate::fillStencilWithVertexArray(QGL2PEXVertexArray& vertexArray, bool useWindingFill)
 {
 //     qDebug("QGL2PaintEngineExPrivate::fillStencilWithVertexArray()");
-    glStencilMask(0xffff); // Enable stencil writes
+    glStencilMask(0xff); // Enable stencil writes
 
     if (dirtyStencilRegion.intersects(currentScissorBounds)) {
         QVector<QRect> clearRegion = dirtyStencilRegion.intersected(currentScissorBounds).rects();
@@ -948,39 +957,30 @@ void QGL2PaintEngineExPrivate::fillStencilWithVertexArray(QGL2PEXVertexArray& ve
 
     if (useWindingFill) {
         if (q->state()->clipTestEnabled) {
+            // Flatten clip values higher than current clip, and set high bit to match current clip
             glStencilFunc(GL_LEQUAL, GL_STENCIL_HIGH_BIT | q->state()->currentClip, ~GL_STENCIL_HIGH_BIT);
             glStencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);
             composite(vertexArray.boundingRect());
 
             glStencilFunc(GL_EQUAL, GL_STENCIL_HIGH_BIT, GL_STENCIL_HIGH_BIT);
-        } else {
-            glStencilFunc(GL_ALWAYS, 0, 0xffff);
+        } else if (!stencilClean) {
+            // Clear stencil buffer within bounding rect
+            glStencilFunc(GL_ALWAYS, 0, 0xff);
             glStencilOp(GL_ZERO, GL_ZERO, GL_ZERO);
             composite(vertexArray.boundingRect());
         }
 
         // Inc. for front-facing triangle
         glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_INCR_WRAP, GL_INCR_WRAP);
-        //Dec. for back-facing "holes"
+        // Dec. for back-facing "holes"
         glStencilOpSeparate(GL_BACK, GL_KEEP, GL_DECR_WRAP, GL_DECR_WRAP);
         glStencilMask(~GL_STENCIL_HIGH_BIT);
         drawVertexArrays(vertexArray, GL_TRIANGLE_FAN);
 
         if (q->state()->clipTestEnabled) {
-            // clear high bit of stencil outside of path
-            glStencilFunc(GL_EQUAL, GL_STENCIL_HIGH_BIT | q->state()->currentClip, ~GL_STENCIL_HIGH_BIT);
-            glStencilOp(GL_KEEP, GL_INVERT, GL_INVERT);
-            glStencilMask(GL_STENCIL_HIGH_BIT);
-            composite(vertexArray.boundingRect());
-            // reset lower bits of stencil inside path to current clip
-            glStencilFunc(GL_EQUAL, GL_STENCIL_HIGH_BIT | q->state()->currentClip, GL_STENCIL_HIGH_BIT);
+            // Clear high bit of stencil outside of path
+            glStencilFunc(GL_EQUAL, q->state()->currentClip, ~GL_STENCIL_HIGH_BIT);
             glStencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);
-            glStencilMask(~GL_STENCIL_HIGH_BIT);
-            composite(vertexArray.boundingRect());
-        } else {
-            // set high bit of stencil inside path
-            glStencilFunc(GL_NOTEQUAL, 0, 0xffff);
-            glStencilOp(GL_KEEP, GL_INVERT, GL_INVERT);
             glStencilMask(GL_STENCIL_HIGH_BIT);
             composite(vertexArray.boundingRect());
         }
@@ -1020,7 +1020,7 @@ void QGL2PaintEngineExPrivate::resetClipIfNeeded()
     QGLRect rect(bounds.left(), bounds.top(), bounds.right(), bounds.bottom());
 
     // Set high bit on clip region
-    glStencilFunc(GL_LEQUAL, q->state()->currentClip, 0xffff);
+    glStencilFunc(GL_LEQUAL, q->state()->currentClip, 0xff);
     glStencilOp(GL_KEEP, GL_INVERT, GL_INVERT);
     glStencilMask(GL_STENCIL_HIGH_BIT);
     composite(rect);
@@ -1028,7 +1028,7 @@ void QGL2PaintEngineExPrivate::resetClipIfNeeded()
     // Reset clipping to 1 and everything else to zero
     glStencilFunc(GL_NOTEQUAL, 0x01, GL_STENCIL_HIGH_BIT);
     glStencilOp(GL_ZERO, GL_REPLACE, GL_REPLACE);
-    glStencilMask(0xFFFF);
+    glStencilMask(0xff);
     composite(rect);
 
     q->state()->currentClip = 1;
@@ -1636,6 +1636,7 @@ bool QGL2PaintEngineEx::begin(QPaintDevice *pdev)
     d->use_system_clip = !systemClip().isEmpty();
 
     d->dirtyStencilRegion = QRect(0, 0, d->width, d->height);
+    d->stencilClean = true;
 
     // Calling begin paint should make the correct context current. So, any
     // code which calls into GL or otherwise needs a current context *must*
@@ -1731,7 +1732,7 @@ void QGL2PaintEngineExPrivate::updateClipScissorTest()
         glStencilFunc(GL_LEQUAL, q->state()->currentClip, ~GL_STENCIL_HIGH_BIT);
     } else {
         glDisable(GL_STENCIL_TEST);
-        glStencilFunc(GL_ALWAYS, 0, 0xffff);
+        glStencilFunc(GL_ALWAYS, 0, 0xff);
     }
 
 #ifdef QT_GL_NO_SCISSOR_TEST
@@ -1787,7 +1788,7 @@ void QGL2PaintEngineExPrivate::clearClip(uint value)
 {
     dirtyStencilRegion -= currentScissorBounds;
 
-    glStencilMask(0xffff);
+    glStencilMask(0xff);
     glClearStencil(value);
     glClear(GL_STENCIL_BUFFER_BIT);
     glStencilMask(0x0);
@@ -1802,6 +1803,8 @@ void QGL2PaintEngineExPrivate::writeClip(const QVectorPath &path, uint value)
     if (matrixDirty)
         updateMatrix();
 
+    stencilClean = false;
+
     const bool singlePass = !path.hasWindingFill()
         && (((q->state()->currentClip == maxClip - 1) && q->state()->clipTestEnabled)
             || q->state()->needsClipBufferClear);
@@ -1819,10 +1822,10 @@ void QGL2PaintEngineExPrivate::writeClip(const QVectorPath &path, uint value)
     if (q->state()->clipTestEnabled)
         glStencilFunc(GL_LEQUAL, q->state()->currentClip, ~GL_STENCIL_HIGH_BIT);
     else
-        glStencilFunc(GL_ALWAYS, 0, 0xffff);
+        glStencilFunc(GL_ALWAYS, 0, 0xff);
 
     vertexCoordinateArray.clear();
-    vertexCoordinateArray.addPath(path, inverseScale);
+    vertexCoordinateArray.addPath(path, inverseScale, false);
 
     if (!singlePass)
         fillStencilWithVertexArray(vertexCoordinateArray, path.hasWindingFill());
@@ -1841,9 +1844,17 @@ void QGL2PaintEngineExPrivate::writeClip(const QVectorPath &path, uint value)
 
         drawVertexArrays(vertexCoordinateArray, GL_TRIANGLE_FAN);
     } else {
-        glStencilFunc(GL_NOTEQUAL, value, GL_STENCIL_HIGH_BIT);
         glStencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);
-        glStencilMask(0xffff);
+        glStencilMask(0xff);
+
+        if (!q->state()->clipTestEnabled && path.hasWindingFill()) {
+            // Pass when any clip bit is set, set high bit
+            glStencilFunc(GL_NOTEQUAL, GL_STENCIL_HIGH_BIT, ~GL_STENCIL_HIGH_BIT);
+            composite(vertexCoordinateArray.boundingRect());
+        }
+
+        // Pass when high bit is set, replace stencil value with new clip value
+        glStencilFunc(GL_NOTEQUAL, value, GL_STENCIL_HIGH_BIT);
 
         composite(vertexCoordinateArray.boundingRect());
     }
diff --git a/src/opengl/gl2paintengineex/qpaintengineex_opengl2_p.h b/src/opengl/gl2paintengineex/qpaintengineex_opengl2_p.h
index 28c972e..46be398 100644
--- a/src/opengl/gl2paintengineex/qpaintengineex_opengl2_p.h
+++ b/src/opengl/gl2paintengineex/qpaintengineex_opengl2_p.h
@@ -223,6 +223,7 @@ public:
     bool shaderMatrixUniformDirty;
     bool opacityUniformDirty;
 
+    bool stencilClean; // Has the stencil not been used for clipping so far?
     QRegion dirtyStencilRegion;
     QRect currentScissorBounds;
     uint maxClip;
diff --git a/src/script/api/qscriptengine_p.h b/src/script/api/qscriptengine_p.h
index 5f31054..f1fc135 100644
--- a/src/script/api/qscriptengine_p.h
+++ b/src/script/api/qscriptengine_p.h
@@ -468,6 +468,22 @@ inline QScriptValue QScriptValuePrivate::property(const QString &name, int resol
     return property(JSC::Identifier(exec, name), resolveMode);
 }
 
+inline void* QScriptValuePrivate::operator new(size_t size, QScriptEnginePrivate *engine)
+{
+    if (engine)
+        return engine->allocateScriptValuePrivate(size);
+    return qMalloc(size);
+}
+
+inline void QScriptValuePrivate::operator delete(void *ptr)
+{
+    QScriptValuePrivate *d = reinterpret_cast<QScriptValuePrivate*>(ptr);
+    if (d->engine)
+        d->engine->freeScriptValuePrivate(d);
+    else
+        qFree(d);
+}
+
 inline void QScriptEnginePrivate::registerScriptString(QScriptStringPrivate *value)
 {
     Q_ASSERT(value->type == QScriptStringPrivate::HeapAllocated);
diff --git a/src/script/api/qscriptvalue.cpp b/src/script/api/qscriptvalue.cpp
index 92c987c..b8340a7 100644
--- a/src/script/api/qscriptvalue.cpp
+++ b/src/script/api/qscriptvalue.cpp
@@ -280,7 +280,7 @@ QScriptValue QScriptValuePrivate::property(const JSC::Identifier &id, int resolv
 {
     Q_ASSERT(isObject());
     JSC::ExecState *exec = engine->currentFrame;
-    JSC::JSObject *object = jscValue.getObject();
+    JSC::JSObject *object = JSC::asObject(jscValue);
     JSC::PropertySlot slot(const_cast<JSC::JSObject*>(object));
     JSC::JSValue result;
     if (const_cast<JSC::JSObject*>(object)->getOwnPropertySlot(exec, id, slot)) {
@@ -303,7 +303,7 @@ QScriptValue QScriptValuePrivate::property(quint32 index, int resolveMode) const
 {
     Q_ASSERT(isObject());
     JSC::ExecState *exec = engine->currentFrame;
-    JSC::JSObject *object = jscValue.getObject();
+    JSC::JSObject *object = JSC::asObject(jscValue);
     JSC::PropertySlot slot(const_cast<JSC::JSObject*>(object));
     JSC::JSValue result;
     if (const_cast<JSC::JSObject*>(object)->getOwnPropertySlot(exec, index, slot)) {
@@ -466,22 +466,6 @@ void QScriptValuePrivate::detachFromEngine()
     engine = 0;
 }
 
-void* QScriptValuePrivate::operator new(size_t size, QScriptEnginePrivate *engine)
-{
-    if (engine)
-        return engine->allocateScriptValuePrivate(size);
-    return qMalloc(size);
-}
-
-void QScriptValuePrivate::operator delete(void *ptr)
-{
-    QScriptValuePrivate *d = reinterpret_cast<QScriptValuePrivate*>(ptr);
-    if (d->engine)
-        d->engine->freeScriptValuePrivate(d);
-    else
-        qFree(d);
-}
-
 /*!
   \internal
 */
diff --git a/src/script/api/qscriptvalue_p.h b/src/script/api/qscriptvalue_p.h
index 6cbda97..351d616 100644
--- a/src/script/api/qscriptvalue_p.h
+++ b/src/script/api/qscriptvalue_p.h
@@ -68,8 +68,8 @@ class QScriptValuePrivate
 {
     Q_DISABLE_COPY(QScriptValuePrivate);
 public:
-    void* operator new(size_t, QScriptEnginePrivate*);
-    void operator delete(void*);
+    inline void* operator new(size_t, QScriptEnginePrivate*);
+    inline void operator delete(void*);
 
     enum Type {
         JavaScriptCore,