Changeset 61 for trunk/src/kernel/qregion_pm.cpp

Timestamp:

Feb 6, 2006, 10:43:39 PM (20 years ago)

Author:

dmik

Message:

Implemented QRegion(..., QRegion::Eclipse) and QRegion(QPointArray &,...) constructors.
Improved Qt<->GPI region coordinates translation (it's now implicit), QRegion::handle() takes a height of the target devise as an argument (defaults to 0).

File:

• trunk/src/kernel/qregion_pm.cpp (modified) (14 diffs)

trunk/src/kernel/qregion_pm.cpp

@@ -43 +43 @@
 #include "qt_os2.h"
 
-// We always create a GPI resuorce for a region with top and bottom corner
-// points made negative and swapped. This gives us no-cost top to bottom
-// flipping but requires to call GpiOffsetRegion() to offset the region up by
-// the height of the presentation space viewport before it is actually used on
-// that presentation space (usually for clipping) and, on the contrary, offset
-// the region got from GPI down before it is stored in QRegion.
+//  To compensate the difference between Qt (where y axis goes downwards) and
+//  GPI (where y axis goes upwards) coordinate spaces when dealing with regions
+//  we use the following technique: when a GPI resource is allocated for a Qt
+//  region, we simply change the sign of all y coordinates to quickly flip it
+//  top to bottom in a manner that doesn't depend on the target device height.
+//  All we have to do to apply the created GPI region to a particular GPI device
+//  is to align its y axis to the top of the device (i.e. offset the region
+//  up by the height of the device), and unalign it afterwards to bring it back
+//  to the coordinate space of other device-independent (unaligned) regions.
+//  To optimize this, we remember (in data->hgt) the last height value used to
+//  align the region, and align it again only if the target device height
+//  changes. Zero height indicates a device-independent target (such as other
+//  unaligned Qt region).
+//
+//  The handle() function, used for external access to the region, takes an
+//  argument that must be always set to the height of the target device to
+//  guarantee the correct coordinate space alignment.
+
+#if defined(Q_CC_GNU) && !defined(USE_OS2_TOOLKIT_HEADERS)
+
+// Innotek GCC lacks some API functions in its version of OS/2 Toolkit headers
+
+extern "C" HRGN APIENTRY GpiCreateEllipticRegion( HPS hps,
+                                                  PRECTL prclRect );
+
+extern "C" HRGN APIENTRY GpiCreatePolygonRegion( HPS hps,
+                                                 ULONG ulCount,
+                                                 PPOLYGON paplgn,
+                                                 ULONG flOptions );
+#endif
 
 QRegion::QRegion()
@@ -55 +79 @@
     Q_CHECK_PTR( data );
     data->rgn = 0;
+    data->hgt = 0;
     data->is_null = TRUE;
 }
@@ -63 +88 @@
     Q_CHECK_PTR( data );
     data->rgn = 0;
+    data->hgt = 0;
     data->is_null = is_null;
 }
 
-QRegion::QRegion( const QRect &r, RegionType t )
+QRegion::QRegion( HRGN hrgn, int target_height )
 {
     data = new QRegionData;
     Q_CHECK_PTR( data );
+    data->rgn = hrgn;
+    data->hgt = target_height;
+    data->is_null = FALSE;
+}
+
+QRegion::QRegion( const QRect &r, RegionType t )
+{
+    data = new QRegionData;
+    Q_CHECK_PTR( data );
+    data->hgt = 0;
     data->is_null = FALSE;
     if ( r.isEmpty() ) {
@@ -79 +115 @@
             data->rgn = GpiCreateRegion( hps, 1, &rcl );
         } else if ( t == Ellipse ) {            // elliptic region
-//@@TODO (dmik): create elliptic regions using GpiCreateEllipticRegion() later.
-//  now simply create it as rectangular.
-            RECTL rcl = { r.left(), -(r.bottom()+1), r.right()+1, -r.top() };
-            data->rgn = GpiCreateRegion( hps, 1, &rcl );
+            // if the width or height of the ellipse is odd, GPI always
+            // converts it to a nearest even value, which is obviously stupid
+            // (see also QPainter::drawArcInternal()). So, we don't use
+            // GpiCreateEllipticRegion(), but create an array of points to
+            // call GpiCreatePolygonRegion() instead.
+            QPointArray a;
+            a.makeArc( r.x(), r.y(), r.width(), r.height(), 0, 360 * 16 );
+            for ( uint i = 0; i < a.size(); ++ i )
+                a[i].ry() = -(a[i].y() + 1);
+            // GpiCreatePolygonRegion() is bogus and always starts a poligon from
+            // the current position. Make the last point the current one and reduce
+            // the number of points by one.
+            GpiMove( hps, (PPOINTL) &a[ a.size() - 1 ] );
+            POLYGON poly = { a.size() - 1, (PPOINTL) a.data() };
+            data->rgn = GpiCreatePolygonRegion( hps, 1, &poly, POLYGON_ALTERNATE );
         }
     }
@@ -91 +138 @@
     data = new QRegionData;
     Q_CHECK_PTR( data );
+    data->hgt = 0;
     data->is_null = FALSE;
     QRect r = a.boundingRect();
@@ -96 +144 @@
         data->rgn = 0;
     } else {
-//@@TODO (dmik): create poligonal regions using GpiCreatePolygonRegion() later.
-//  now simply create as bounding rectangle.
-        RECTL rcl = { r.left(), -(r.bottom()+1), r.right()+1, -r.top() };
-        data->rgn = GpiCreateRegion( qt_display_ps(), 1, &rcl );
+        HPS hps = qt_display_ps();
+        POINTL *pts = new POINTL[ a.size() ]; 
+        for ( uint i = 0; i < a.size(); ++ i ) {
+            pts[i].x = a[i].x();
+            pts[i].y = - (a[i].y() + 1);
+        }
+        // GpiCreatePolygonRegion() is bogus and always starts a poligon from
+        // the current position. Make the last point the current one and reduce
+        // the number of points by one.
+        GpiMove( hps, &pts[ a.size() - 1 ] );
+        POLYGON poly = { a.size() - 1, pts };
+        ULONG opts = winding ? POLYGON_WINDING : POLYGON_ALTERNATE;
+        data->rgn = GpiCreatePolygonRegion( hps, 1, &poly, opts );
+        delete[] pts;
     }
 }
@@ -192 +250 @@
     data = new QRegionData;
     Q_CHECK_PTR( data );
+    data->hgt = 0;
     data->is_null = FALSE;
     if ( bm.isNull() )
@@ -225 +284 @@
 {
     QRegion r ( data->is_null );
+    r.data->hgt = 0;
     if ( !data->is_null && data->rgn ) {
         HPS hps = qt_display_ps();
         r.data->rgn = GpiCreateRegion( hps, 0, NULL );
         GpiCombineRegion( hps, r.data->rgn, data->rgn, NULL, CRGN_COPY );
+        r.data->hgt = data->hgt;
     }
     return r;
@@ -252 +313 @@
     LONG rc = PRGN_OUTSIDE;
     if ( data->rgn ) {
-        POINTL ptl = { p.x(), -(p.y()+1) };
+        POINTL ptl = { p.x(), data->hgt - (p.y() + 1) };
         rc = GpiPtInRegion( qt_display_ps(), data->rgn, &ptl );
     }
@@ -262 +323 @@
     LONG rc = PRGN_OUTSIDE;
     if ( data->rgn ) {
-        RECTL rcl = { r.left(), -(r.bottom()+1), r.right()+1, -r.top() };
+        RECTL rcl = { r.left(), data->hgt - (r.bottom() + 1),
+                      r.right() + 1, data->hgt - r.top() };
         rc = GpiRectInRegion( qt_display_ps(), data->rgn, &rcl );
     }
@@ -318 +380 @@
     HPS hps = qt_display_ps();
     result.data->rgn = GpiCreateRegion( hps, 0, NULL );
-    if ( data->rgn && r.data->rgn )
-        GpiCombineRegion( hps, result.data->rgn, data->rgn, r.data->rgn, both );
-    else if ( data->rgn && left != CRGN_NOP )
-        GpiCombineRegion( hps, result.data->rgn, data->rgn, NULL, left );
-    else if ( r.data->rgn && right != CRGN_NOP )
-        GpiCombineRegion( hps, result.data->rgn, r.data->rgn, NULL, right );
+    LONG rc = RGN_NULL; 
+    if ( data->rgn && r.data->rgn ) {
+        updateHandle( r.data->hgt ); // bring to the same coordinate space
+        rc = GpiCombineRegion( hps, result.data->rgn, data->rgn, r.data->rgn, both );
+        result.data->hgt = r.data->hgt;
+    } else if ( data->rgn && left != CRGN_NOP ) {
+        rc = GpiCombineRegion( hps, result.data->rgn, data->rgn, 0, left );
+        result.data->hgt = data->hgt;
+    } else if ( r.data->rgn && right != CRGN_NOP ) {
+        rc = GpiCombineRegion( hps, result.data->rgn, r.data->rgn, 0, right );
+        result.data->hgt = r.data->hgt;
+    }
+    if ( rc == RGN_NULL || rc == RGN_ERROR ) {
+        GpiDestroyRegion( hps, result.data->rgn );
+        result.data->rgn = result.data->hgt = 0;
+    }
     return result;
 }
@@ -354 +426 @@
     if ( data->rgn )
         rc = GpiQueryRegionBox( qt_display_ps(), data->rgn, &rcl );
-    if ( rc == RGN_NULL )
+    if ( rc == RGN_NULL || rc == RGN_ERROR )
         return QRect(0,0,0,0);
     else
-        return QRect(rcl.xLeft, -rcl.yTop, rcl.xRight-rcl.xLeft, rcl.yTop-rcl.yBottom );
+        return QRect( rcl.xLeft, data->hgt - rcl.yTop,
+                      rcl.xRight - rcl.xLeft, rcl.yTop - rcl.yBottom );
 }
 
@@ -382 +455 @@
     PRECTL r = rcls;
     for ( int i=0; i<(int)a.size(); i++ ) {
-        a[i].setRect( r->xLeft, -r->yTop, r->xRight-r->xLeft, r->yTop-r->yBottom );
+        a[i].setRect( r->xLeft, data->hgt - r->yTop,
+                      r->xRight - r->xLeft, r->yTop - r->yBottom );
         r++;
     }
@@ -407 +481 @@
     if ( (is_empty ^ r_is_empty ) )             // one is empty, not both
         return FALSE;
-    return is_empty ?
-        TRUE :                                  // both empty
-        GpiEqualRegion( qt_display_ps(), data->rgn, r.data->rgn ) == EQRGN_EQUAL;
-}
-
-void QRegion::update() const
-{
-    // lazy initialization. this method should be called only from handle()
-    data->rgn = GpiCreateRegion( qt_display_ps(), 0, NULL );
-}
+    if ( is_empty )                             // both empty
+        return TRUE;
+    updateHandle( r.data->hgt ); // bring to the same coordinate space
+    return
+        GpiEqualRegion( qt_display_ps(), data->rgn, r.data->rgn ) == EQRGN_EQUAL;
+}
+
+/*!
+ *  \internal
+ *  Updates the region handle so that it is suitable for selection to
+ *  a device with the given \a height.
+ */
+void QRegion::updateHandle( int target_height ) const
+{
+    QRegion *that = const_cast< QRegion *>( this ); // we're const here
+    if ( !data->rgn ) {
+        // a handle of a null region is requested, allocate an empty region
+        that->data->rgn = GpiCreateRegion( qt_display_ps(), 0, NULL );
+        that->data->hgt = target_height;
+    } else if ( data->hgt != target_height ) {
+        // align region y axis to the top of the device
+        POINTL ptl = { 0, target_height - data->hgt };
+        GpiOffsetRegion( qt_display_ps(), data->rgn, &ptl );
+        that->data->hgt = target_height;
+    }
+}