Fix pens, at small sizes

See 504c489d40e815397235ba26df7f06aae821c88a
Also fixes 0 width (hairline) pens.

2 files changed, 90 insertions, 59 deletions

diff --git a/src/declarative/fx/qfxrect.cpp b/src/declarative/fx/qfxrect.cpp
index 6f13d7c..b61baec 100644
--- a/src/declarative/fx/qfxrect.cpp
+++ b/src/declarative/fx/qfxrect.cpp
@@ -52,6 +52,11 @@ QML_DEFINE_TYPE(QFxPen,Pen);
     \ingroup group_utility
     \brief The QFxPen class provides a pen used for drawing rect borders on a QFxView.
 
+    By default, the pen is invalid and nothing is drawn. You must either set a color (then the default
+    width is 0) or a width (then the default color is black).
+
+    A width of 0 is a single-pixel line on the border of the item being painted.
+
     Example:
     \qml
     Rect { pen.width: 2; pen.color: "red" ... }
@@ -61,8 +66,9 @@ QML_DEFINE_TYPE(QFxPen,Pen);
 /*! \property QFxPen::width
     \brief the width of the pen.
 
-    The default width is 1. If the width is less than 1 the pen is considered invalid
-    and won't be used.
+    A width of 0 is a single-pixel line on the border of the item being painted.
+
+    If the width is less than 0 the pen is considered invalid and won't be used.
 */
 
 /*!
@@ -99,12 +105,14 @@ void QFxPen::setColor(const QColor &c)
     Rect { pen.width: 4 }
     \endqml
 
+    A width of 0 creates a thin line. For no line, use a negative width or a transparent color.
+
     Odd pen widths generally lead to half-pixel painting.
 */
 void QFxPen::setWidth(int w)
 {
     _width = w;
-    _valid = (_width < 1) ? false : true;
+    _valid = (_width < 0) ? false : true;
     emit updated();
 }
 
@@ -436,9 +444,13 @@ void QFxRect::generateRoundedRect()
         QImage roundRect(d->_radius*2 + 4 + pw*2, d->_radius*2 + 4 + pw*2, QImage::Format_ARGB32_Premultiplied);
         roundRect.fill(0);
         QPainter p(&roundRect);
-        QPen pn(QColor(pen()->color()), pen()->width());
         p.setRenderHint(QPainter::Antialiasing);
-        p.setPen(pn);
+        if (d->_pen && d->_pen->isValid()) {
+            QPen pn(QColor(pen()->color()), pen()->width());
+            p.setPen(pn);
+        } else {
+            p.setPen(Qt::NoPen);
+        }
         p.setBrush(d->_color);
         p.drawRoundedRect((pw+1)/2, (pw+1)/2, roundRect.width()-(pw+1)/2*2, roundRect.height()-(pw+1)/2*2, d->_radius, d->_radius);
         d->_rectTexture.setImage(roundRect);
@@ -453,9 +465,13 @@ void QFxRect::generateBorderedRect()
         QImage borderedRect(pw*2 + 4, pw*2 + 4, QImage::Format_ARGB32_Premultiplied);
         borderedRect.fill(0);
         QPainter p(&(borderedRect));
-        QPen pn(QColor(pen()->color()), pen()->width());
         p.setRenderHint(QPainter::Antialiasing);
-        p.setPen(pn);
+        if (d->_pen && d->_pen->isValid()) {
+            QPen pn(QColor(pen()->color()), pen()->width());
+            p.setPen(pn);
+        } else {
+            p.setPen(Qt::NoPen);
+        }
         p.setBrush(d->_color);
         p.drawRect(qreal(pw+1)/2, qreal(pw+1)/2, borderedRect.width()-(pw+1)/2*2, borderedRect.height()-(pw+1)/2*2);
         d->_rectTexture.setImage(borderedRect);
@@ -524,18 +540,22 @@ void QFxRect::drawRect(QPainter &p)
         }
 
         //basically same code as QFxImage uses to paint sci images
-        int w = width();
-        int h = height();
+        int w = width()+pw;
+        int h = height()+pw;
         int xOffset = offset;
         int xSide = xOffset * 2;
+        bool xMiddles=true;
         if (xSide > w) {
-            xOffset = w/2;
+            xMiddles=false;
+            xOffset = w/2 + 1;
             xSide = xOffset * 2;
         }
         int yOffset = offset;
         int ySide = yOffset * 2;
+        bool yMiddles=true;
         if (ySide > h) {
-            yOffset = h/2;
+            yMiddles = false;
+            yOffset = h/2 + 1;
             ySide = yOffset * 2;
         }
 
@@ -543,40 +563,37 @@ void QFxRect::drawRect(QPainter &p)
         p.drawImage(QRect(-pw/2, -pw/2, xOffset, yOffset), d->_rectImage, QRect(0, 0, xOffset, yOffset));
 
         // Upper middle
-        if (d->_rectImage.width() - xSide)
+        if (xMiddles)
             p.drawImage(QRect(xOffset-pw/2, -pw/2, width() - xSide + pw, yOffset), d->_rectImage,
                                   QRect(d->_rectImage.width()/2, 0, 1, yOffset));
         // Upper right
-        if (d->_rectImage.width() - xOffset) {
-            p.drawImage(QPoint(width()-xOffset+pw/2, -pw/2), d->_rectImage,
-                                  QRect(d->_rectImage.width()-xOffset, 0, xOffset, yOffset));
-        }
+        p.drawImage(QPoint(width()-xOffset+pw/2, -pw/2), d->_rectImage,
+                              QRect(d->_rectImage.width()-xOffset, 0, xOffset, yOffset));
         // Middle left
-        if (d->_rectImage.height() - ySide)
+        if (yMiddles)
             p.drawImage(QRect(-pw/2, yOffset-pw/2, xOffset, height() - ySide + pw), d->_rectImage,
                                   QRect(0, d->_rectImage.height()/2, xOffset, 1));
 
         // Middle
-        if (d->_rectImage.width() - xSide && d->_rectImage.height() - ySide)
+        if (xMiddles && yMiddles)
             // XXX paint errors in animation example
             //p.fillRect(xOffset-pw/2, yOffset-pw/2, width() - xSide + pw, height() - ySide + pw, d->getColor());
             p.drawImage(QRect(xOffset-pw/2, yOffset-pw/2, width() - xSide + pw, height() - ySide + pw), d->_rectImage,
                                 QRect(d->_rectImage.width()/2, d->_rectImage.height()/2, 1, 1));
         // Middle right
-        if (d->_rectImage.height() - ySide)
+        if (yMiddles)
             p.drawImage(QRect(width()-xOffset+pw/2, yOffset-pw/2, xOffset, height() - ySide + pw), d->_rectImage,
                                 QRect(d->_rectImage.width()-xOffset, d->_rectImage.height()/2, xOffset, 1));
         // Lower left 
         p.drawImage(QPoint(-pw/2, height() - yOffset + pw/2), d->_rectImage, QRect(0, d->_rectImage.height() - yOffset, xOffset, yOffset));
 
         // Lower Middle
-        if (d->_rectImage.width() - xSide)
+        if (xMiddles)
             p.drawImage(QRect(xOffset-pw/2, height() - yOffset +pw/2, width() - xSide + pw, yOffset), d->_rectImage,
                                 QRect(d->_rectImage.width()/2, d->_rectImage.height() - yOffset, 1, yOffset));
         // Lower Right
-        if (d->_rectImage.width() - xOffset)
-            p.drawImage(QPoint(width()-xOffset+pw/2, height() - yOffset+pw/2), d->_rectImage,
-                            QRect(d->_rectImage.width()-xOffset, d->_rectImage.height() - yOffset, xOffset, yOffset));
+        p.drawImage(QPoint(width()-xOffset+pw/2, height() - yOffset+pw/2), d->_rectImage,
+                        QRect(d->_rectImage.width()-xOffset, d->_rectImage.height() - yOffset, xOffset, yOffset));
     }
 }
 #endif
@@ -650,22 +667,36 @@ void QFxRect::paintGLContents(GLPainter &p)
 
         QGLShaderProgram *shader = p.useTextureShader();
 
-        float imgWidth = d->_rectTexture.width();
-        float imgHeight = d->_rectTexture.height();
-        if (!imgWidth || !imgHeight)
+        float texWidth = d->_rectTexture.width();
+        float texHeight = d->_rectTexture.height();
+        if (!texWidth || !texHeight)
             return;
 
         float widthV = qreal(width())+pw/2;
         float heightV = qreal(height())+pw/2;
 
-        float texleft = float(offset) / imgWidth;
-        float imgleft = offset-pw/2;
-        float texright = float(imgWidth-offset) / imgWidth;
-        float imgright = widthV - offset;
-        float textop = float(imgHeight-offset) / imgHeight;
-        float imgtop = offset-pw/2;
-        float texbottom = float(offset) / imgHeight;
-        float imgbottom = heightV - offset;
+        float xOffset = offset;
+        bool xMiddles = true;
+        if (xOffset*2 > width()+pw) {
+            xMiddles = false;
+            xOffset = (width()+pw)/2;
+        }
+        float yOffset = offset;
+        bool yMiddles = true;
+        if (yOffset*2 > height()+pw) {
+            yMiddles = false;
+            yOffset = (height()+pw)/2;
+        }
+
+        float texleft = xOffset / texWidth;
+        float imgleft = xOffset-pw/2;
+        float texright = (texWidth-xOffset) / texWidth;
+        float imgright = widthV - xOffset;
+
+        float textop = yOffset / texHeight;
+        float imgtop = yOffset-pw/2;
+        float texbottom = (texHeight-yOffset) / texHeight;
+        float imgbottom = heightV - yOffset;
 
         //Bug 231768: Inappropriate interpolation was occuring on 3x3 textures
         if (offset==1)
@@ -703,31 +734,31 @@ void QFxRect::paintGLContents(GLPainter &p)
                          texright, texbottom,
                          1, textop,
                          1, texbottom };
-        float vert3[] = { -pw/2, imgbottom,
-                          -pw/2, heightV,
-                          imgleft, imgbottom,
+        float vert3[] = { -pw/2, heightV,
+                          -pw/2, imgbottom,
                           imgleft, heightV,
-                          imgright, imgbottom,
+                          imgleft, imgbottom,
                           imgright, heightV,
-                          widthV, imgbottom,
-                          widthV, heightV };
-        float tex3[] = { 0, texbottom,
-                         0, 0,
+                          imgright, imgbottom,
+                          widthV, heightV,
+                          widthV, imgbottom };
+        float tex3[] = { 0, 1,
+                         0, texbottom,
+                         texleft, 1,
                          texleft, texbottom,
-                         texleft, 0,
+                         texright, 1,
                          texright, texbottom,
-                         texright, 0,
-                         1, texbottom,
-                         1, 0 };
-
-        glBindTexture(GL_TEXTURE_2D, d->_rectTexture.texture());
+                         1, 1,
+                         1, texbottom };
 
         shader->setAttributeArray(SingleTextureShader::Vertices, vert1, 2);
         shader->setAttributeArray(SingleTextureShader::TextureCoords, tex1, 2);
         glDrawArrays(GL_TRIANGLE_STRIP, 0, 8);
-        shader->setAttributeArray(SingleTextureShader::Vertices, vert2, 2);
-        shader->setAttributeArray(SingleTextureShader::TextureCoords, tex2, 2);
-        glDrawArrays(GL_TRIANGLE_STRIP, 0, 8);
+        if (yMiddles) {
+            shader->setAttributeArray(SingleTextureShader::Vertices, vert2, 2);
+            shader->setAttributeArray(SingleTextureShader::TextureCoords, tex2, 2);
+            glDrawArrays(GL_TRIANGLE_STRIP, 0, 8);
+        }
         shader->setAttributeArray(SingleTextureShader::Vertices, vert3, 2);
         shader->setAttributeArray(SingleTextureShader::TextureCoords, tex3, 2);
         glDrawArrays(GL_TRIANGLE_STRIP, 0, 8);
@@ -806,9 +837,9 @@ void QFxRect::paintGLContents(GLPainter &p)
             glColor4f(1, 1, 1, p.activeOpacity);
         }
 
-        float imgWidth = d->_rectTexture.width();
-        float imgHeight = d->_rectTexture.height();
-        if (!imgWidth || !imgHeight)
+        float texWidth = d->_rectTexture.width();
+        float texHeight = d->_rectTexture.height();
+        if (!texWidth || !texHeight)
             return;
 
         float widthV = width();
@@ -823,13 +854,13 @@ void QFxRect::paintGLContents(GLPainter &p)
         float imgtop = 0;
         float imgbottom = heightV;
 
-        texleft = float(offset) / imgWidth;
+        texleft = float(offset) / texWidth;
         imgleft = offset;
-        texright = 1. - float(offset) / imgWidth;
+        texright = 1. - float(offset) / texWidth;
         imgright = widthV - offset;
-        textop = 1. - float(offset) / imgHeight;
+        textop = 1. - float(offset) / texHeight;
         imgtop = offset;
-        texbottom = float(offset) / imgHeight;
+        texbottom = float(offset) / texHeight;
         imgbottom = heightV - offset;
 
         float vert1[] = { 0, 0, 
diff --git a/src/declarative/fx/qfxrect.h b/src/declarative/fx/qfxrect.h
index 339a7d8..84a9c57 100644
--- a/src/declarative/fx/qfxrect.h
+++ b/src/declarative/fx/qfxrect.h
@@ -58,7 +58,7 @@ class Q_DECLARATIVE_EXPORT QFxPen : public QObject
     Q_PROPERTY(QColor color READ color WRITE setColor)
 public:
     QFxPen(QObject *parent=0)
-        : QObject(parent), _width(1), _color("#000000"), _valid(false)
+        : QObject(parent), _width(0), _color("#000000"), _valid(false)
     {}
 
     int width() const { return _width; }