Changeset 71 for trunk/src/canvas/qcanvas.cpp

Timestamp:

Mar 22, 2006, 4:15:38 PM (19 years ago)

Author:

dmik

Message:

On OS/2, use regions to scan polygons in order to determine which chunks they intersect with. This should be as fast as QPolygonScanner, but produces much better results (and no artefacts).

File:

• trunk/src/canvas/qcanvas.cpp (modified) (8 diffs)

trunk/src/canvas/qcanvas.cpp

@@ -1082 +1082 @@
 
 #ifndef QT_NO_TRANSFORMATIONS
+#if !defined(Q_WS_PM)
         // For translation-only transformation, it is safe to include the right
         // and bottom edges, but otherwise, these must be excluded since they
@@ -1090 +1091 @@
         else
             a = QPointArray( all );
+#else
+        // Polygons on OS/2 already include the right and bottom edges
+        // (why shouldn't they do that?) Indeed, this important moment is not
+        // defined in Qt at all. 
+        QPointArray a( all );
+#endif
 
         a = (wm*twm).map(a);
 #else
+#if !defined(Q_WS_PM)
         QPointArray a( QRect(all.x(),all.y(),all.width()+1,all.height()+1) );
+#else        
+        QPointArray a( all );
+#endif        
 #endif
         if ( view->viewport()->backgroundMode() == NoBackground ) {
@@ -3940 +3951 @@
             int x2r = x2%8;
 #ifdef QCANVAS_POLYGONS_DEBUG
-            if ( dbg_ptr ) dbg_ptr->setPen(Qt::yellow);
+            if ( dbg_ptr ) dbg_ptr->setPen(Qt::darkGray);
 #endif
             if ( x1q == x2q ) {
                 uchar newbits = (~l[x1q]) & (((2<<(x2r-x1r))-1)<<x1r);
                 if ( newbits ) {
+                    addBits(x1r,x2r,newbits,x1q*8,y);
+                    l[x1q] |= newbits;
 #ifdef QCANVAS_POLYGONS_DEBUG
                     if ( dbg_ptr ) dbg_ptr->setPen(Qt::darkGreen);
 #endif
-                    addBits(x1r,x2r,newbits,x1q*8,y);
-                    l[x1q] |= newbits;
                 }
             } else {
-#ifdef QCANVAS_POLYGONS_DEBUG
-                if ( dbg_ptr ) dbg_ptr->setPen(Qt::blue);
-#endif
                 uchar newbits1 = (~l[x1q]) & (0xff<<x1r);
                 if ( newbits1 ) {
+                    addBits(x1r,7,newbits1,x1q*8,y);
+                    l[x1q] |= newbits1;
 #ifdef QCANVAS_POLYGONS_DEBUG
                     if ( dbg_ptr ) dbg_ptr->setPen(Qt::green);
 #endif
-                    addBits(x1r,7,newbits1,x1q*8,y);
-                    l[x1q] |= newbits1;
                 }
                 for (int i=x1q+1; i<x2q; i++) {
@@ -3967 +3975 @@
                         addBits(0,7,~l[i],i*8,y);
                         l[i]=0xff;
+#ifdef QCANVAS_POLYGONS_DEBUG
+                        if ( dbg_ptr ) dbg_ptr->setPen(Qt::black);
+#endif
                     }
                 }
                 uchar newbits2 = (~l[x2q]) & (0xff>>(7-x2r));
                 if ( newbits2 ) {
+                    addBits(0,x2r,newbits2,x2q*8,y);
+                    l[x2q] |= newbits2;
 #ifdef QCANVAS_POLYGONS_DEBUG
                     if ( dbg_ptr ) dbg_ptr->setPen(Qt::red);
 #endif
-                    addBits(0,x2r,newbits2,x2q*8,y);
-                    l[x2q] |= newbits2;
                 }
             }
@@ -3987 +3998 @@
     }
 
+#if defined(Q_WS_PM)
+    // We cannot use QPolygonScanner, because:
+    // a) polygons in OS/2 are all-inclusive, but
+    // b) specifying the Bottom edge inclusion in QPolygonScanner::scan()
+    //    doesn't actually work (seems that the code from Xserver always
+    //    internally assumes that right and bottom edges are excluded).
+    // Instead of getting into and fixing the Xserver code, I decided to use
+    // region's rectangles to determine polygon spans. It should be as fast
+    // as the Xserver code, but gives us one more advantage: spans detected
+    // this way precisely repeat the actual polygon pixels drawn on the screen
+    // (because both regions and polygons are created/drawn by GPI using the
+    // same line and fill routines), so all chunks will be correctly detected.
+    
+    void scanPolygon( const QPointArray &pa, bool wind )
+    {
+        int cs = canvas->chunkSize();
+        QRegion rgn = QRegion( pa, wind );
+        QMemArray <QRect> rects = rgn.rects();
+        for ( size_t i = 0; i < rects.size(); ++ i ) {
+            const QRect &r = rects[i];
+            int width = r.width() - 1;
+            // I think I saw null rects in regions a couple of times...
+            if ( width < 0 || r.height() == 0 )
+                continue;
+            QPoint pt( r.topLeft() );
+            while ( 1 ) {
+                doSpans( 1, &pt, &width );
+#ifdef QCANVAS_POLYGONS_DEBUG
+                if ( dbg_ptr ) {
+                    dbg_ptr->setPen( Qt::cyan );
+                    QPoint ptd = pt;
+                    ++ ptd.ry();
+                    int j = 1;
+                    for ( ; j < cs && ptd.y() < r.bottom(); ++ j, ++ ptd.ry() )
+                        dbg_ptr->drawLine( ptd, ptd + QPoint( width, 0 ) );
+                }
+#endif
+                if ( pt.y() == r.bottom() )
+                    break;
+                pt.ry() += cs;
+                if ( pt.y() > r.bottom() )
+                    pt.ry() = r.bottom();
+            }
+        }
+    }
+#endif // !defined(Q_WS_PM)
+
     int pnt;
     QPointArray result;
@@ -4003 +4061 @@
         return pa;
     }
-
+    
     QPolygonalProcessor processor(canvas(),pa);
 
+#if defined(Q_WS_PM)
+    processor.scanPolygon( pa, wind );
+#else
     scanPolygon(pa, wind, processor);
+#endif    
 
     return processor.result;
@@ -5352 +5414 @@
 }
 
+#if !defined(Q_WS_PM)
+
 class QCanvasPolygonScanner : public QPolygonScanner {
     QPolygonalProcessor& processor;
@@ -5371 +5435 @@
 }
 
+#endif    
 
 #endif // QT_NO_CANVAS