Changeset 1273 for cairo

Timestamp:

Jan 24, 2016, 11:23:30 PM (9 years ago)

Author:

dmik

Message:

cairo: Rewrite cairo-os2-surface.c to remove app-specific code and add new features.

Based on a patch by Rich Walsh with some adaptions to the newer upstream version
(see #87 for details).

Location:

cairo/trunk

Files:

• src/cairo-os2-private.h (modified) (3 diffs)
• src/cairo-os2-surface.c (modified) (4 diffs)
• src/cairo-os2.h (modified) (4 diffs)
• test/error-setters.c (modified) (1 diff)

cairo/trunk/src/cairo-os2-private.h ¶

@@ -3 +3 @@
  *
  * Copyright (c) 2005-2006 netlabs.org
+ * Copyright (c) 2010-2011 Rich Walsh
  *
  * This library is free software; you can redistribute it and/or
@@ -34 +35 @@
  * Contributor(s):
  *     Peter Weilbacher <mozilla@Weilbacher.org>
+ *     Rich Walsh <rich@e-vertise.com>
  */
 
@@ -39 +41 @@
 #define CAIRO_OS2_PRIVATE_H
 
+#include "cairoint.h"
 #include "cairo-os2.h"
-#include "cairoint.h"
 
-typedef struct _cairo_os2_surface
-{
-    cairo_surface_t        base;
+/**
+ * Unpublished API:
+ *   GpiEnableYInversion = PMGPI.723
+ *   GpiQueryYInversion = PMGPI.726
+ **/
 
-    /* Mutex semaphore to protect private fields from concurrent access */
-    HMTX                   hmtx_use_private_fields;
-    /* Private fields: */
-    HPS                    hps_client_window;
-    HWND                   hwnd_client_window;
-    BITMAPINFO2            bitmap_info;
-    unsigned char         *pixels;
-    cairo_image_surface_t *image_surface;
-    int                    pixel_array_lend_count;
-    HEV                    hev_pixel_array_came_back;
+BOOL APIENTRY GpiEnableYInversion (HPS hps, LONG lHeight);
+LONG APIENTRY GpiQueryYInversion (HPS hps);
 
-    RECTL                  rcl_dirty_area;
-    cairo_bool_t           dirty_area_present;
+/**
+ * Function declaration for GpiDrawBits () (missing from OpenWatcom headers)
+ **/
+#ifdef __WATCOMC__
+LONG APIENTRY GpiDrawBits (HPS hps, PVOID pBits,
+                           PBITMAPINFO2 pbmiInfoTable,
+                           LONG lCount, PPOINTL aptlPoints,
+                           LONG lRop, ULONG flOptions);
+#endif
 
-    /* General flags: */
-    cairo_bool_t           blit_as_changes;
-    cairo_bool_t           use_24bpp;
+/**
+ * Support for dynamically loading dive.dll -
+ * use to avoid both compile-time and run-time dependencies
+ **/
+
+#ifdef OS2_DYNAMIC_DIVE
+typedef ULONG (APIENTRY *DiveQuery_t)(void*, ULONG);
+typedef ULONG (APIENTRY *DiveOpen_t)(ULONG*, BOOL, VOID*);
+typedef ULONG (APIENTRY *DiveClose_t)(ULONG);
+typedef ULONG (APIENTRY *DiveAcquire_t)(ULONG, RECTL*);
+typedef ULONG (APIENTRY *DiveDeacquire_t)(ULONG);
+
+#define ORD_DIVEQUERYCAPS             1
+#define ORD_DIVEOPEN                  2
+#define ORD_DIVECLOSE                 3
+#define ORD_DIVEACQUIREFRAMEBUFFER    6
+#define ORD_DIVEDEACQUIREFRAMEBUFFER  8
+#endif
+
+/**
+ * OS/2 surface subtypes
+ **/
+
+typedef enum _cairo_os2_subtype {
+    CAIRO_OS2_SUBTYPE_NULL = 0,
+    CAIRO_OS2_SUBTYPE_IMAGE
+} cairo_os2_subtype_t;
+
+/**
+ * MMIO bitmap formats defined here to avoid #including
+ * multiple headers that aren't otherwise needed.
+ **/
+
+#ifndef FOURCC_BGR4
+#define FOURCC_BGR4 0x34524742
+#endif
+#ifndef FOURCC_BGR3
+#define FOURCC_BGR3 0x33524742
+#endif
+
+/**
+ * cairo_os2_surface_t:
+ * 
+ * @base: Standard #cairo_surface_t structure.
+ * @subtype: This #cairo_os2_surface-specific value identifies whether the
+ *   surface will be used for images or as a dummy with no image.
+ * @width: Width of the surface in pixels.
+ * @height: Height of the surface in pixels.
+ * @hps: PM presentation space handle whose ownership is retained by the
+ *   caller.  Required for printing surfaces, optional otherwise.
+ * @format: Standard #cairo_format_t value.
+ * @content: Standard #cairo_content_t value.
+ * @hwnd: PM window handle whose ownership is retained by the caller.
+ *   Required for surfaces associated with a window and ignored otherwise.
+ * @stride: Distance in bytes from the start of one scan line to the next.
+ * @data: Pointer to the memory #cairo_image_surface_t uses for its bitmap.
+ *   It is allocated and freed by cairo_os2_surface_t and is not accessible
+ *   outside this module.
+ * @image: Pointer to the underlying image surface. It is only used for
+ *   subtype %CAIRO_OS2_SUBTYPE_IMAGE.
+ **/
+
+typedef struct _cairo_os2_surface {
+    /* common data */
+    cairo_surface_t         base;
+    cairo_os2_subtype_t     subtype;
+    int                     width;
+    int                     height;
+    HPS                     hps;
+    cairo_format_t          format;
+    cairo_content_t         content;
+
+    /* image surface data */
+    HWND                    hwnd;
+    int                     stride;
+    unsigned char          *data;
+    cairo_surface_t        *image;
+
 } cairo_os2_surface_t;
 

cairo/trunk/src/cairo-os2-surface.c ¶

@@ -3 +3 @@
  *
  * Copyright (c) 2005-2006 netlabs.org
+ * Copyright (c) 2010-2011 Rich Walsh
  *
  * This library is free software; you can redistribute it and/or
@@ -34 +35 @@
  * Contributor(s):
  *     Peter Weilbacher <mozilla@Weilbacher.org>
- *     Rich Walsh <dragtext@e-vertise.com>
+ *     Rich Walsh <rich@e-vertise.com>
+ *     Dmitriy Kuminov <coding@dmik.org>
  */
 
-#include "cairoint.h"
-
+
+/**
+ * cairo_os2_surface:
+ *
+ * #cairo_os2_surface is a thin wrapper around #cairo_image_surface that
+ * supports output to displays and native bitmaps.  It provides OS/2-specific
+ * front-end functions and manages memory used by surface bitmaps.  Calls
+ * to most backend functions are forwarded to the underlying image surface.
+ **/
+
+#define INCL_DOS
+#define INCL_WIN
+#define INCL_GPI
+#include <os2.h>
+
+#include <dive.h>
 #include "cairo-os2-private.h"
 #include "cairo-default-context-private.h"
@@ -45 +61 @@
 #include "cairo-image-surface-private.h"
 
-/*
- * This function calls the allocation function depending on which
- * method was compiled into the library: it can be native allocation
- * (DosAllocMem/DosFreeMem) or C-Library based allocation (malloc/free).
- * Actually, for pixel buffers that we use this function for, cairo
- * uses _cairo_malloc_abc, so we use that here, too. And use the
- * change to check the size argument
- */
-void *_buffer_alloc (size_t a, size_t b, const unsigned int size)
-{
-    size_t nbytes;
-    void  *buffer = NULL;
-
-    if (!a || !b || !size ||
-        a >= INT32_MAX / b || a*b >= INT32_MAX / size) {
-        return NULL;
-    }
-    nbytes = a * b * size;
+/**
+ *  Forward references to static helper functions
+ **/
+
+static cairo_status_t
+_cairo_os2_surface_init_image (cairo_os2_surface_t *surface);
+static unsigned char *
+_cairo_os2_surface_alloc (unsigned int size);
+static void
+_cairo_os2_surface_free (void *buffer);
+static cairo_status_t
+_cairo_os2_surface_paint_32bpp (cairo_os2_surface_t *surface,
+                                HPS                  hps,
+                                RECTL               *src,
+                                RECTL               *dst,
+                                int                  count);
+static cairo_status_t
+_cairo_os2_surface_paint_24bpp (cairo_os2_surface_t *surface,
+                                HPS                  hps,
+                                RECTL               *src,
+                                RECTL               *dst,
+                                int                  count);
+static cairo_status_t
+_cairo_os2_surface_paint_dive (cairo_os2_surface_t *surface,
+                               HPS                  hps,
+                               RECTL               *rect,
+                               int                  count);
+static void
+_cairo_os2_surface_dive_error (void);
+
+
+/**
+ * Module-level data
+ **/
+
+static cairo_bool_t   display_use24bpp = FALSE;
+static int            dive_status = 0;
+static cairo_bool_t   dive_hideptr = TRUE;
+static HDIVE          dive_handle = 0;
+static int            dive_height;
+static int            dive_stride;
+static unsigned char *dive_scrnbuf;
+
+
+/**
+ * Support for dynamically loading dive.dll
+ **/
+
+#ifdef OS2_DYNAMIC_DIVE
+static cairo_bool_t      dive_loaded = FALSE;
+
+static DiveQuery_t       pDiveQueryCaps = 0;
+static DiveOpen_t        pDiveOpen = 0;
+static DiveClose_t       pDiveClose = 0;
+static DiveAcquire_t     pDiveAcquireFrameBuffer = 0;
+static DiveDeacquire_t   pDiveDeacquireFrameBuffer = 0;
+
+#define DiveQueryCaps             pDiveQueryCaps
+#define DiveOpen                  pDiveOpen
+#define DiveClose                 pDiveClose
+#define DiveAcquireFrameBuffer    pDiveAcquireFrameBuffer
+#define DiveDeacquireFrameBuffer  pDiveDeacquireFrameBuffer
+
+static cairo_bool_t
+_cairo_os2_surface_load_dive (void);
+#endif
+
+
+/**
+ * Forward reference to the backend structure
+ **/
+
+static const
+cairo_surface_backend_t cairo_os2_surface_backend;
+
+
+/**
+ *
+ * Surface Create functions
+ *
+ **/
+
+/**
+ * cairo_os2_surface_create:
+ * @format: a standard cairo_format_t value
+ * @width: width of the surface in pixels
+ * @height: height of the surface in pixels
+ *
+ * A generic image surface creation function.
+ *
+ * Returns: a cairo_os2_surface_t if successful, a nil surface if not.
+ *
+ * Since: 1.12
+ **/
+
+cairo_public cairo_surface_t *
+cairo_os2_surface_create (cairo_format_t      format,
+                          int                 width,
+                          int                 height)
+{
+    cairo_status_t       status;
+    cairo_os2_surface_t *surface;
+
+    if (width < 0 || height < 0)
+        return _cairo_surface_create_in_error (CAIRO_STATUS_INVALID_SIZE);
+
+    if (!CAIRO_FORMAT_VALID(format))
+        return _cairo_surface_create_in_error (CAIRO_STATUS_INVALID_FORMAT);
+
+    /*
+     * Create an OS/2 wrapper for an image surface
+     * whose bitmap will be allocated from system memory.
+     */
+    surface = malloc (sizeof (cairo_os2_surface_t));
+    if (unlikely (surface == NULL))
+        return _cairo_surface_create_in_error (CAIRO_STATUS_NO_MEMORY);
+
+    memset (surface, 0, sizeof(cairo_os2_surface_t));
+    surface->format  = format;
+    surface->content = _cairo_content_from_format (surface->format);
+    surface->subtype = CAIRO_OS2_SUBTYPE_IMAGE;
+    surface->width   = width;
+    surface->height  = height;
+    surface->stride  = cairo_format_stride_for_width (format, width);
+
+    /*
+     * allocate memory for a bitmap then create an image surface.
+     */
+    status = _cairo_os2_surface_init_image (surface);
+    if (_cairo_status_is_error(status)) {
+        if (surface->image)
+            cairo_surface_destroy (surface->image);
+        if (surface->data)
+            _cairo_os2_surface_free (surface->data);
+        free (surface);
+        return _cairo_surface_create_in_error (status);
+    }
+
+    _cairo_surface_init (&surface->base, &cairo_os2_surface_backend,
+                         NULL, surface->content);
+
+    return &surface->base;
+}
+
+
+/**
+ * cairo_os2_surface_create_for_window:
+ * @hwnd: window associated with this surface
+ * @width: width of the surface in pixels
+ * @height: height of the surface in pixels
+ *
+ * This creates a destination surface that maps to the entire area of
+ * a native window.  Clients can call cairo_os2_surface_set_size() when
+ * the window's size changes, and cairo_os2_surface_paint_window()
+ * when they want to update the display with the surface's content.
+ *
+ * If @hwnd is not supplied with this call, it must be set using
+ * cairo_os2_surface_set_hwnd() before attempting to display this surface.
+ *
+ * Returns: a cairo_os2_surface_t if successful, a nil surface if not.
+ *
+ * Since: 1.12
+ **/
+
+cairo_public cairo_surface_t *
+cairo_os2_surface_create_for_window (HWND  hwnd,
+                                     int   width,
+                                     int   height)
+{
+    cairo_os2_surface_t *surface;
+
+    surface = (cairo_os2_surface_t *)
+              cairo_os2_surface_create (CAIRO_FORMAT_ARGB32, width, height);
+
+    if (!_cairo_status_is_error (surface->base.status))
+        surface->hwnd = hwnd;
+
+    return &surface->base;
+}
+
+
+/**
+ * cairo_os2_surface_create_null_surface:
+ * @hps: presentation space handle, typically associated with a
+ *   printer's device context
+ * @width: width of the surface in pixels
+ * @height: height of the surface in pixels
+ *
+ * This creates a a null surface that has no image surface associated
+ * with it.  It is created when the client needs a surface that can be
+ * queried for its attributes but won't actually be used.
+ *
+ * Returns: a cairo_os2_surface_t if successful, a nil surface if not.
+ *
+ * Since: 1.12
+ **/
+
+cairo_public cairo_surface_t *
+cairo_os2_surface_create_null_surface (HPS  hps,
+                                       int  width,
+                                       int  height)
+{
+    cairo_os2_surface_t *surface;
+
+    if (width < 0 || height < 0)
+        return _cairo_surface_create_in_error (CAIRO_STATUS_INVALID_SIZE);
+
+    surface = malloc (sizeof (cairo_os2_surface_t));
+    if (unlikely (surface == NULL))
+        return _cairo_surface_create_in_error (CAIRO_STATUS_NO_MEMORY);
+
+    memset (surface, 0, sizeof(cairo_os2_surface_t));
+    surface->format  = CAIRO_FORMAT_ARGB32;
+    surface->content = _cairo_content_from_format (surface->format);
+    surface->subtype = CAIRO_OS2_SUBTYPE_NULL;
+    surface->width   = width;
+    surface->height  = height;
+    surface->hps     = hps;
+
+    _cairo_surface_init (&surface->base, &cairo_os2_surface_backend,
+                         NULL, surface->content);
+
+    return &surface->base;
+}
+
+
+/**
+ *
+ * OS/2-specific functions
+ *
+ **/
+
+/**
+ * cairo_os2_surface_paint_window:
+ * @surface: the cairo_os2_surface to display
+ * @hps: presentation space handle associated with the target window
+ * @rect: an array of native RECTL structure identifying the bottom-left
+ *   and top-right corners of the areas to be displayed
+ * @count: the number RECTLs in @rect's array
+ *
+ * This function paints the specified areas of a window using the supplied
+ * surface. It is intended for surfaces whose dimensions have a 1-to-1
+ * mapping to the dimensions of a native window (such as those created by
+ * cairo_os2_surface_create_for_window()).  As such, each rectangle identifies
+ * the coordinates for both the source bitmap and the destination window.  The
+ * window's handle must already be associated with this surface, using either
+ * cairo_os2_surface_create_for_window() or cairo_os2_surface_set_hwnd().
+ *
+ * It attempts to use the most efficient method available to move the image
+ * to the screen.  If an attempt fails, it falls back to the next method.
+ * If all attempts fail, the surface is marked as being in an error state.
+ *
+ * If @rect is %NULL, the entire window will be repainted.  @hps is
+ * typically the presentation space handle returned by WinBeginPaint().
+ * If it is null, cairo_os2_surface_paint_window() will use the HPS
+ * that was previously associated with this surface.  If that too is null,
+ * it will allocate (and later destroy) an HPS for the window handle
+ * associated with this surface.
+ *
+ * Returns: %CAIRO_STATUS_SUCCESS if successful,
+ *          %CAIRO_STATUS_DEVICE_ERROR if a permanent fatal error occurs,
+ *          or one of several errors if arguments are missing or invalid.
+ *
+ * Since: 1.12
+ **/
+
+cairo_public cairo_status_t
+cairo_os2_surface_paint_window (cairo_surface_t *surface,
+                                HPS              hps,
+                                RECTL           *rect,
+                                int              count)
+{
+    cairo_os2_surface_t *os2surf = (cairo_os2_surface_t *) surface;
+    cairo_status_t       status = CAIRO_STATUS_SUCCESS;
+    HPS                  hpsTemp = 0;
+    RECTL                rectTemp;
+
+    if (unlikely (!surface || (rect && !count)))
+        return _cairo_error (CAIRO_STATUS_NULL_POINTER);
+
+    if (cairo_surface_get_type (surface) != CAIRO_SURFACE_TYPE_OS2 ||
+        os2surf->subtype != CAIRO_OS2_SUBTYPE_IMAGE || !os2surf->hwnd)
+        return _cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH);
+
+    /* If an HPS wasn't provided, see if we can get one. */
+    if (!hps) {
+        hps = os2surf->hps;
+        if (!hps) {
+            if (os2surf->hwnd) {
+                hpsTemp = WinGetPS(os2surf->hwnd);
+                hps = hpsTemp;
+            }
+            /* No HPS & no way to get one, so exit */
+            if (!hps)
+                return _cairo_error (CAIRO_STATUS_DEVICE_ERROR);
+         }
+    }
+
+    /* If rect is null, paint the entire window. */
+    if (!rect) {
+        rectTemp.xLeft = 0;
+        rectTemp.xRight = os2surf->width;
+        rectTemp.yTop = os2surf->height;
+        rectTemp.yBottom = 0;
+        rect = &rectTemp;
+        count = 1;
+     }
+
+    if (dive_handle) {
+        if (_cairo_os2_surface_paint_dive (os2surf, hps, rect, count) ==
+                                                        CAIRO_STATUS_SUCCESS)
+            goto done;
+    }
+    if (!display_use24bpp) {
+        if (_cairo_os2_surface_paint_32bpp (os2surf, hps, rect, rect, count) ==
+                                                        CAIRO_STATUS_SUCCESS)
+            goto done;
+        display_use24bpp = TRUE;
+    }
+    status = _cairo_os2_surface_paint_24bpp (os2surf, hps, rect, rect, count);
+    if (status == CAIRO_STATUS_SUCCESS)
+        goto done;
+
+    status = _cairo_surface_set_error (&os2surf->base, status);
+
+done:
+    if (hpsTemp)
+        WinReleasePS (hpsTemp);
+
+    return status;
+}
+
+
+/**
+ * cairo_os2_surface_paint_bitmap:
+ * @surface: the cairo_os2_surface to display
+ * @hps: presentation space handle associated with the target device
+ * @src: an array of native RECTL structure identifying those areas of
+ *   the source surface which will be painted onto the destination
+ * @dst: an array of native RECTL structure that identify where on the
+ *   destination surface the corresponding @src rectangles will be painted
+ * @count: the number of RECTLs in @src and @dst arrays
+ * @use24bpp: if set, the surface's 32bpp bitmap is copied to a 24bpp
+ *    bitmap before blitting to @hps
+ *
+ * This function paints the specified areas of a presentation space using
+ * the supplied surface.  The target of the operation can be a PM bitmap
+ * which the caller has previously created and selected into @hps, or it
+ * can be an @hps associated with a window or printer.  Only GPI functions
+ * will be used for blitting - DIVE is not available.
+ *
+ * Neither the origins nor dimensions of the @src and @dst rectangles need
+ * be the same:  translation and scaling will occur as required.  Either
+ * @src or @dst can be %NULL if there is a 1-to-1 mapping between the source
+ * and destination's coordinates.  If both @src and @dst are %NULL, the
+ * entire surface's contents will be painted into the presentation space.
+ *
+ * If the driver for the device context associated with @hps is known to
+ * be unable to use 32-bit bitmap data as input (e.g. most native printer
+ * drivers), the @use24bpp flag should be set.  Its use is very expensive
+ * and should be avoided unless absolutely necessary.
+ *
+ * If cairo_os2_surface_set_hps() was used to associate an HPS with this
+ * surface using, @hps may be %NULL;  otherwise, it must be supplied.
+ *
+ * Returns: %CAIRO_STATUS_SUCCESS if successful,
+ *          %CAIRO_STATUS_DEVICE_ERROR if the bit-blit fails,
+ *          or one of several errors if arguments are missing or invalid.
+ *
+ * Since: 1.12
+ **/
+
+cairo_public cairo_status_t
+cairo_os2_surface_paint_bitmap (cairo_surface_t *surface,
+                                HPS              hps,
+                                RECTL           *src,
+                                RECTL           *dst,
+                                int              count,
+                                BOOL             use24bpp)
+{
+    cairo_os2_surface_t *os2surf = (cairo_os2_surface_t *) surface;
+    cairo_status_t       status = CAIRO_STATUS_SUCCESS;
+    RECTL                rectTemp;
+
+    if (unlikely (!surface || ((src || dst) && !count)))
+        return _cairo_error (CAIRO_STATUS_NULL_POINTER);
+
+    if (cairo_surface_get_type (surface) != CAIRO_SURFACE_TYPE_OS2 ||
+        os2surf->subtype != CAIRO_OS2_SUBTYPE_IMAGE)
+         return _cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH);
+
+    if (!hps) {
+        if (!os2surf->hps)
+            return _cairo_error (CAIRO_STATUS_DEVICE_ERROR);
+        hps = os2surf->hps;
+     }
+
+    /* If either src or dst is null, assume a 1 to 1 mapping of
+     * coordinates;  if both are null, copy all of src to dst.
+     */
+    if (!src) {
+        if (!dst) {
+            rectTemp.xLeft = 0;
+            rectTemp.xRight = os2surf->width;
+            rectTemp.yTop = os2surf->height;
+            rectTemp.yBottom = 0;
+            src = dst = &rectTemp;
+            count = 1;
+        }
+        else
+            src = dst;
+    }
+    else
+        if (!dst)
+            dst = src;
+
+    /* Perform either a 32-bit or 24-bit blit, depending on @use24bpp. */
+    if (use24bpp)
+        status = _cairo_os2_surface_paint_24bpp (os2surf, hps, src, dst, count);
+    else
+        status = _cairo_os2_surface_paint_32bpp (os2surf, hps, src, dst, count);
+
+    return status;
+}
+
+
+/**
+ * cairo_os2_surface_get_hps:
+ * @surface: the cairo_os2_surface to query
+ * @hps: presentation space handle associated with this surface
+ *
+ * Retrieves the HPS associated with this surface, if any.
+ *
+ * Returns: %CAIRO_STATUS_SUCCESS if successful,
+ *          or one of several errors if arguments are missing or invalid.
+ *
+ * Since: 1.12
+ **/
+
+cairo_public cairo_status_t
+cairo_os2_surface_get_hps (cairo_surface_t *surface,
+                           HPS             *hps)
+{
+    cairo_os2_surface_t *os2surf = (cairo_os2_surface_t *) surface;
+
+    if (unlikely (!surface || !hps))
+        return _cairo_error (CAIRO_STATUS_NULL_POINTER);
+
+    if (cairo_surface_get_type (surface) != CAIRO_SURFACE_TYPE_OS2)
+        return _cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH);
+
+    *hps = os2surf->hps;
+
+    return CAIRO_STATUS_SUCCESS;
+}
+
+/**
+ * cairo_os2_surface_set_hps:
+ * @surface: a cairo_os2_surface
+ * @hps: presentation space handle to associate with this surface
+ *
+ * Associates an HPS with this surface or dissociates it if @hps is %NULL.
+ * The caller retains ownership of @hps and must destroy it when it is no
+ * longer needed.
+ *
+ * Returns: %CAIRO_STATUS_SUCCESS if successful,
+ *          or one of several errors if arguments are missing or invalid.
+ *
+ * Since: 1.12
+ **/
+
+cairo_public cairo_status_t
+cairo_os2_surface_set_hps (cairo_surface_t *surface,
+                           HPS              hps)
+{
+    cairo_os2_surface_t *os2surf = (cairo_os2_surface_t *) surface;
+
+    if (unlikely (!surface))
+        return _cairo_error (CAIRO_STATUS_NULL_POINTER);
+
+    if (cairo_surface_get_type (surface) != CAIRO_SURFACE_TYPE_OS2)
+        return _cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH);
+
+    os2surf->hps = hps;
+
+    return CAIRO_STATUS_SUCCESS;
+}
+
+
+/**
+ * cairo_os2_surface_set_hwnd:
+ * @surface: a cairo_os2_surface
+ * @hwnd: window handle to associate with this surface
+ *
+ * Associates an HWND with this surface or dissociates it if @hwnd is %NULL.
+ * The caller retains ownership of @hwnd.  If the surface was created without
+ * supplying an HWND, this function must be called before attempting to use
+ * cairo_os2_surface_paint_window().
+ *
+ * Returns: %CAIRO_STATUS_SUCCESS if successful,
+ *          or one of several errors if arguments are missing or invalid.
+ *
+ * Since: 1.12
+ **/
+
+cairo_public cairo_status_t
+cairo_os2_surface_set_hwnd (cairo_surface_t *surface,
+                            HWND             hwnd)
+{
+    cairo_os2_surface_t *os2surf = (cairo_os2_surface_t *) surface;
+
+    if (unlikely (!surface))
+        return _cairo_error (CAIRO_STATUS_NULL_POINTER);
+
+    if (cairo_surface_get_type (surface) != CAIRO_SURFACE_TYPE_OS2)
+        return _cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH);
+
+    os2surf->hwnd = hwnd;
+
+    return CAIRO_STATUS_SUCCESS;
+}
+
+
+/**
+ * cairo_os2_surface_set_size:
+ * @surface: the cairo_os2_surface to resize
+ * @width: the surface's new width
+ * @height: the surface's new height
+ * @copy: boolean indicating whether existing bitmap data should
+ *   be copied to the resized surface
+ *
+ * This function resizes a cairo_os2_surface and its underlying image
+ * surface. It is intended for surfaces whose dimensions have a 1-to-1
+ * mapping to the dimensions of a native window (such as those created
+ * by cairo_os2_surface_create_for_window()).
+ *
+ * If @copy is non-zero, bitmap data will be copied from the original
+ * image surface to its replacement.  The bitmaps will be aligned at
+ * their top-left corners.
+ *
+ * Returns: %CAIRO_STATUS_SUCCESS if successful,
+ *          or one of several errors if arguments are missing or invalid.
+ *
+ * Since: 1.12
+ **/
+
+cairo_public cairo_status_t
+cairo_os2_surface_set_size (cairo_surface_t *surface,
+                            int              width,
+                            int              height,
+                            int              copy)
+{
+    cairo_os2_surface_t *os2surf = (cairo_os2_surface_t *) surface;
+    cairo_surface_t     *old_image;
+    int                  old_width;
+    int                  old_height;
+    int                  old_stride;
+    unsigned char       *old_data;
+    cairo_status_t       status = CAIRO_STATUS_SUCCESS;
+
+    if (unlikely (!surface))
+        return _cairo_error (CAIRO_STATUS_NULL_POINTER);
+
+    if (cairo_surface_get_type (surface) != CAIRO_SURFACE_TYPE_OS2)
+         return _cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH);
+
+    if (width < 0 || height < 0)
+         return _cairo_error (CAIRO_STATUS_INVALID_SIZE);
+
+    old_image   = os2surf->image;
+    old_width   = os2surf->width;
+    old_height  = os2surf->height;
+    old_stride  = os2surf->stride;
+    old_data    = os2surf->data;
+
+    os2surf->image  = 0;
+    os2surf->width  = width;
+    os2surf->height = height;
+    os2surf->stride = cairo_format_stride_for_width (os2surf->format, width);
+    os2surf->data   = 0;
+
+    if (os2surf->subtype != CAIRO_OS2_SUBTYPE_NULL)
+        status = _cairo_os2_surface_init_image (os2surf);
+
+    if (_cairo_status_is_error(status)) {
+        if (os2surf->image)
+            cairo_surface_destroy (os2surf->image);
+        if (os2surf->data)
+            _cairo_os2_surface_free (os2surf->data);
+        os2surf->image  = old_image;
+        os2surf->width  = old_width;
+        os2surf->height = old_height;
+        os2surf->stride = old_stride;
+        os2surf->data   = old_data;
+        return status;
+     }
+
+    if (copy) {
+        unsigned char *src = old_data;
+        unsigned char *dst = os2surf->data;
+        int count  = (old_stride < os2surf->stride) ? old_stride : os2surf->stride;
+        int height = (old_height < os2surf->height) ? old_height : os2surf->height;
+
+        while (height) {
+            memcpy(dst, src, count);
+            src += old_stride;
+            dst += os2surf->stride;
+            height--;
+        }
+     }
+
+    if (old_image)
+        cairo_surface_destroy (old_image);
+    if (old_data)
+        _cairo_os2_surface_free (old_data);
+
+    return status;
+}
+
+
+/**
+ * cairo_os2_surface_enable_dive:
+ *
+ * @enable: boolean indicating whether DIVE should be enabled or disabled
+ * @hide_pointer: boolean indicating whether the mouse pointer should be
+ *   removed from the screen while writing to the frame buffer.
+ *
+ * This function enables or disables DIVE.  When enabled, image data is
+ * written directly to the video framebuffer, bypassing OS/2's graphics
+ * subsystem.  Only 32-bit (BGR4) and 24-bit (BGR3) color modes are
+ * supported.  If any other video mode is in effect, or if any error
+ * occurs while initializing or using DIVE, it will be disabled for
+ * the remainder of the process.
+ *
+ * The @hide_pointer argument avoids screen corruption when DIVE is used
+ * with less-capable video drivers that use a software-generated pointer.
+ *
+ * Returns: %TRUE if the desired state (enabled or disabled) can be
+ *  achieved or is already in effect, and FALSE otherwise.
+ *
+ * Since: 1.12
+ **/
+
+cairo_public cairo_bool_t
+cairo_os2_surface_enable_dive (cairo_bool_t enable,
+                               cairo_bool_t hide_pointer)
+{
+    unsigned int  rc;
+    unsigned int  dive_fmts[64];
+    DIVE_CAPS     dive_caps;
+    char          msg[8];
+
+    /* If DIVE is disabled due to an earlier error, return false. */
+    if (dive_status == -1)
+        return FALSE;
+
+    /* Close DIVE if it is currently enabled and reset all values. */
+    if (!enable) {
+        if (dive_handle)
+            DiveClose (dive_handle);
+        dive_handle = 0;
+        dive_scrnbuf = 0;
+        dive_hideptr = TRUE;
+        dive_status = 0;
+        return TRUE;
+    }
+
+    /* If DIVE is already enabled, do nothing. */
+    if (dive_status)
+        return TRUE;
+
+    /* Assume the worst. */
+    dive_status = -1;
+
+#ifdef OS2_DYNAMIC_DIVE
+    if (!dive_loaded) {
+        dive_loaded = TRUE;
+        if (!_cairo_os2_surface_load_dive ())
+            return FALSE;
+    }
+#endif
+
+    memset (&dive_caps, 0, sizeof(dive_caps));
+    memset (dive_fmts, 0, sizeof(dive_fmts));
+    dive_caps.ulStructLen = sizeof(dive_caps);
+    dive_caps.ulFormatLength = sizeof(dive_fmts);
+    dive_caps.pFormatData = dive_fmts;
+
+    /* Get the driver's DIVE capabilities. */
+    rc = DiveQueryCaps (&dive_caps, DIVE_BUFFER_SCREEN);
+    if (rc)
+        return FALSE;
+
+    /* Only 32-bit (BGR4) and 24-bit (BGR3) color modes
+     * are supported.  If the mode is anything else, exit.
+     */
+    memcpy(msg, &dive_caps.fccColorEncoding, 4);
+    msg[4] = 0;
+    if (dive_caps.fccColorEncoding != FOURCC_BGR4) {
+        if (dive_caps.fccColorEncoding == FOURCC_BGR3)
+            display_use24bpp = TRUE;
+        else
+            return FALSE;
+    }
+
+    dive_height = dive_caps.ulVerticalResolution;
+    dive_stride = dive_caps.ulScanLineBytes;
+
+    /* Open a DIVE instance and get the address of the frame buffer. */
+    rc = DiveOpen(&dive_handle, FALSE, (void*)&dive_scrnbuf);
+    if (rc)
+        return FALSE;
+
+    /* Success. */
+    dive_hideptr = hide_pointer;
+    dive_status = 1;
+
+    return TRUE;
+}
+
+
+/**
+ *
+ * Backend functions
+ *
+ **/
+
+static cairo_surface_t *
+_cairo_os2_surface_create_similar (void             *abstract_other,
+                                   cairo_content_t   content,
+                                   int               width,
+                                   int               height)
+{
+    cairo_os2_surface_t *other = abstract_other;
+
+    if (unlikely (other->base.status))
+        return _cairo_surface_create_in_error (other->base.status);
+
+    if (unlikely (!CAIRO_CONTENT_VALID (content)))
+        return _cairo_surface_create_in_error (CAIRO_STATUS_INVALID_CONTENT);
+
+    if (other->subtype == CAIRO_OS2_SUBTYPE_IMAGE)
+        return cairo_os2_surface_create (_cairo_format_from_content (content),
+                                         width, height);
+
+    if (other->subtype == CAIRO_OS2_SUBTYPE_NULL)
+        return cairo_os2_surface_create_null_surface (other->hps, width, height);
+
+    return _cairo_surface_create_in_error (CAIRO_STATUS_INVALID_FORMAT);
+}
+
+
+static cairo_status_t
+_cairo_os2_surface_finish (void *abstract_surface)
+{
+    cairo_os2_surface_t *surface = abstract_surface;
+    if (surface->image)
+        cairo_surface_destroy (surface->image);
+    if (surface->data)
+        _cairo_os2_surface_free (surface->data);
+
+    return CAIRO_STATUS_SUCCESS;
+}
+
+
+static cairo_status_t
+_cairo_os2_surface_acquire_source_image (void                    *abstract_surface,
+                                         cairo_image_surface_t  **image_out,
+                                         void                   **image_extra)
+{
+    cairo_os2_surface_t *surface = abstract_surface;
+
+    if (!surface->image)
+        return CAIRO_STATUS_NULL_POINTER;
+
+    return _cairo_surface_acquire_source_image (surface->image,
+                                                image_out, image_extra);
+}
+
+
+static void
+_cairo_os2_surface_release_source_image (void                   *abstract_surface,
+                                         cairo_image_surface_t  *image,
+                                         void                   *image_extra)
+{
+}
+
+static cairo_surface_t *
+_cairo_os2_surface_map_to_image (void *abstract_surface,
+                                 const cairo_rectangle_int_t *extents)
+{
+    cairo_os2_surface_t *surface = abstract_surface;
+
+    if (!surface->image)
+        return _cairo_surface_create_in_error (CAIRO_STATUS_NULL_POINTER);
+
+    return cairo_surface_map_to_image (surface->image, extents);
+}
+
+
+static cairo_int_status_t
+_cairo_os2_surface_unmap_image (void *abstract_surface,
+                                cairo_image_surface_t *image)
+{
+    cairo_os2_surface_t *surface = abstract_surface;
+
+    if (!surface->image)
+        return CAIRO_STATUS_NULL_POINTER;
+
+    cairo_surface_unmap_image (surface->image, &image->base);
+    return cairo_surface_status (surface->image);
+}
+
+
+static cairo_bool_t
+_cairo_os2_surface_get_extents (void                   *abstract_surface,
+                                cairo_rectangle_int_t  *rectangle)
+{
+    cairo_os2_surface_t *surface = abstract_surface;
+
+    rectangle->x = 0;
+    rectangle->y = 0;
+    rectangle->width  = surface->width;
+    rectangle->height = surface->height;
+
+    return TRUE;
+}
+
+
+static void
+_cairo_os2_surface_get_font_options (void                  *abstract_surface,
+                                     cairo_font_options_t  *options)
+{
+    cairo_os2_surface_t *surface = abstract_surface;
+
+    if (surface->image)
+        cairo_surface_get_font_options (surface->image, options);
+    else
+        _cairo_font_options_init_default (options);
+}
+
+
+static const cairo_surface_backend_t cairo_os2_surface_backend = {
+    CAIRO_SURFACE_TYPE_OS2,
+    _cairo_os2_surface_finish,
+
+    _cairo_default_context_create,
+
+    _cairo_os2_surface_create_similar,
+    NULL, /* create_similar_image */
+    _cairo_os2_surface_map_to_image,
+    _cairo_os2_surface_unmap_image,
+
+    _cairo_surface_default_source,
+    _cairo_os2_surface_acquire_source_image,
+    _cairo_os2_surface_release_source_image,
+    NULL, /* snapshot */
+
+    NULL, /* copy_page */
+    NULL, /* show_page */
+
+    _cairo_os2_surface_get_extents,
+    _cairo_os2_surface_get_font_options,
+
+    NULL, /* flush */
+    NULL, /* mark_dirty_rectangle */
+
+    _cairo_surface_fallback_paint,
+    _cairo_surface_fallback_mask,
+    _cairo_surface_fallback_stroke,
+    _cairo_surface_fallback_fill,
+    NULL, /* fill/stroke */
+    _cairo_surface_fallback_glyphs,
+};
+
+
+/**
+ *
+ *  Static helper functions
+ *
+ **/
+
+/**
+ * _cairo_os2_surface_init_image:
+ * @surface: the cairo_os2_surface to associate with an cairo_image_surface
+ *
+ * Creates the image surface that underlies a cairo_os2_surface.
+ * If the surface's area is not empty, it allocates the memory the image
+ * surface will use for its bitmap.  The image surface is always created,
+ * regardless of whether its area is empty and is left in its default state
+ * of transparent black.
+ *
+ * Returns: %CAIRO_STATUS_SUCCESS if successful,
+ *          %CAIRO_STATUS_NO_MEMORY if an image buffer can't be allocated,
+ *          or one of several errors if image_surface creation fails.
+ *
+ * Since: 1.12
+ **/
+
+static cairo_status_t
+_cairo_os2_surface_init_image (cairo_os2_surface_t *surface)
+{
+    cairo_status_t status;
+    int            size = surface->stride * surface->height;
+
+    if (size) {
+        surface->data = _cairo_os2_surface_alloc (size);
+        if (!surface->data)
+            return CAIRO_STATUS_NO_MEMORY;
+    }
+
+    surface->image = cairo_image_surface_create_for_data (surface->data,
+                                                          surface->format,
+                                                          surface->width,
+                                                          surface->height,
+                                                          surface->stride);
+
+    status = cairo_surface_status (surface->image);
+    if (_cairo_status_is_error(status))
+        return status;
+
+    return status;
+}
+
+
+/**
+ * _cairo_os2_surface_alloc:
+ * @size: the number of bytes to allocate
+ *
+ * Allocates the memory passed to cairo_image_surface_create_for_data()
+ * that will be used for its bitmap.
+ *
+ * Returns: a pointer to the newly allocated buffer if successful,
+ *          %NULL otherwise.
+ *
+ * Since: 1.12
+ **/
+
+static unsigned char *
+_cairo_os2_surface_alloc (unsigned int size)
+{
+    void  *buffer;
 
 #ifdef OS2_USE_PLATFORM_ALLOC
-    /* Using OBJ_ANY on a machine that isn't configured for hi-mem
-     * will cause ERROR_INVALID_PARAMETER.  If this occurs, or this
-     * build doesn't have hi-mem enabled, fall back to using lo-mem.
-     */
-#ifdef OS2_HIGH_MEMORY
-    if (!DosAllocMem (&buffer, nbytes,
+# ifdef OS2_HIGH_MEMORY
+    if (!DosAllocMem (&buffer, size,
                       OBJ_ANY | PAG_READ | PAG_WRITE | PAG_COMMIT))
         return buffer;
+# endif
+    if (DosAllocMem (&buffer, size,
+                     PAG_READ | PAG_WRITE | PAG_COMMIT))
+        buffer = NULL;
+
+    return buffer;
+#else
+    buffer = malloc (size);
+    if (buffer)
+        memset (buffer, 0, size);
+
+    return buffer;
 #endif
-    if (DosAllocMem (&buffer, nbytes,
-                     PAG_READ | PAG_WRITE | PAG_COMMIT))
-        return NULL;
-#else
-    /* Clear the malloc'd buffer the way DosAllocMem() does. */
-    buffer = malloc (nbytes);
-    if (buffer) {
-        memset (buffer, 0, nbytes);
-    }
-#endif
-    return buffer;
-}
-
-/*
- * This function selects the free function depending on which
- * allocation method was compiled into the library
- */
-void _buffer_free (void *buffer)
+}
+
+
+/**
+ * _cairo_os2_surface_free:
+ * @buffer: the allocation to free
+ *
+ * Frees bitmap-data memory allocated by _cairo_os2_surface_alloc.
+ *
+ * Returns: no return value,
+ *
+ * Since: 1.12
+ **/
+
+static void
+_cairo_os2_surface_free (void *buffer)
 {
 #ifdef OS2_USE_PLATFORM_ALLOC
@@ -100 +1046 @@
 }
 
-/*
- * The following part of the source file contains the code which might
- * be called the "core" of the OS/2 backend support. This contains the
- * OS/2 surface support functions and structures.
- */
-
-/* Forward declaration */
-static const cairo_surface_backend_t cairo_os2_surface_backend;
-
-/* Unpublished API:
- *   GpiEnableYInversion = PMGPI.723
- *   GpiQueryYInversion = PMGPI.726
- *   BOOL APIENTRY GpiEnableYInversion (HPS hps, LONG lHeight);
- *   LONG APIENTRY GpiQueryYInversion (HPS hps);
- */
-BOOL APIENTRY GpiEnableYInversion (HPS hps, LONG lHeight);
-LONG APIENTRY GpiQueryYInversion (HPS hps);
-
-#ifdef __WATCOMC__
-/* Function declaration for GpiDrawBits () (missing from OpenWatcom headers) */
-LONG APIENTRY GpiDrawBits (HPS hps,
-                           PVOID pBits,
-                           PBITMAPINFO2 pbmiInfoTable,
-                           LONG lCount,
-                           PPOINTL aptlPoints,
-                           LONG lRop,
-                           ULONG flOptions);
-#endif
-
-static void
-_cairo_os2_surface_blit_pixels (cairo_os2_surface_t *surface,
-                                HPS                  hps_begin_paint,
-                                PRECTL               prcl_begin_paint_rect)
-{
-    POINTL aptlPoints[4];
-    LONG   lOldYInversion;
-    LONG   rc = GPI_OK;
-
-    /* Check the limits (may not be necessary) */
-    if (prcl_begin_paint_rect->xLeft < 0)
-        prcl_begin_paint_rect->xLeft = 0;
-    if (prcl_begin_paint_rect->yBottom < 0)
-        prcl_begin_paint_rect->yBottom = 0;
-    if (prcl_begin_paint_rect->xRight > (LONG) surface->bitmap_info.cx)
-        prcl_begin_paint_rect->xRight = (LONG) surface->bitmap_info.cx;
-    if (prcl_begin_paint_rect->yTop > (LONG) surface->bitmap_info.cy)
-        prcl_begin_paint_rect->yTop = (LONG) surface->bitmap_info.cy;
-
-    /* Exit if the rectangle is empty */
-    if (prcl_begin_paint_rect->xLeft   >= prcl_begin_paint_rect->xRight ||
-        prcl_begin_paint_rect->yBottom >= prcl_begin_paint_rect->yTop)
-        return;
-
-    /* Set the Target & Source coordinates */
-    *((PRECTL)&aptlPoints[0]) = *prcl_begin_paint_rect;
-    *((PRECTL)&aptlPoints[2]) = *prcl_begin_paint_rect;
-
-    /* Make the Target coordinates non-inclusive */
-    aptlPoints[1].x -= 1;
-    aptlPoints[1].y -= 1;
-
-    /* Enable Y Inversion for the HPS, so  GpiDrawBits will
-     * work with upside-top image, not with upside-down image!
+
+/**
+ * _cairo_os2_surface_paint_32bpp:
+ * @surface: the cairo_os2_surface to display
+ * @hps: presentation space handle associated with the target device
+ * @src: an array of native RECTL structure identifying those areas of
+ *   the source surface which will be painted onto the destination
+ * @dst: an array of native RECTL structure that identify where on the
+ *   destination surface the corresponding @src rectangles will be painted
+ * @count: the number of RECTLs in @src and @dst arrays
+ *
+ * Uses standard GPI functions and structures to paint selected portions
+ * of the surface onto the presentation space identified by @hps.  If
+ * the @src and @dst rectangles are not the same size, GpiDrawBits() will
+ * expand or compress the image as needed.  Y-inversion is temporarily
+ * enabled for the presentation space so that Cairo's top-line-first
+ * bitmaps will be handled correctly.
+ *
+ * This function assumes the driver for the device context associated
+ * with @hps is able to handle 32-bit bitmap data as input and can
+ * convert it to an appropriate format/color-depth as needed.  If not,
+ * the function returns %CAIRO_STATUS_DEVICE_ERROR to signal that the
+ * 24-bit version of this function should be used instead.
+ *
+ * Returns: %CAIRO_STATUS_SUCCESS if successful,
+ *          %CAIRO_STATUS_DEVICE_ERROR if the bit-blit fails.
+ *
+ * Since: 1.12
+ **/
+
+static cairo_status_t
+_cairo_os2_surface_paint_32bpp (cairo_os2_surface_t *surface,
+                                HPS                  hps,
+                                RECTL               *src,
+                                RECTL               *dst,
+                                int                  count)
+{
+    cairo_status_t status = CAIRO_STATUS_SUCCESS;
+    int            inversion;
+    int            ndx;
+    BITMAPINFO2    bmi;
+
+    /* Set up the bitmap header for 32bit depth. */
+    memset(&bmi, 0, sizeof (BITMAPINFO2));
+    bmi.cbFix = sizeof (BITMAPINFO2) - sizeof (bmi.argbColor[0]);
+    bmi.cx = surface->width;
+    bmi.cy = surface->height;
+    bmi.cPlanes = 1;
+    bmi.cBitCount = 32;
+
+    /* Enable Y Inversion for the HPS, so  GpiDrawBits will work with
+     * Cairo's top-line-first bitmap (vs OS/2's bottom-line-first bitmaps)
      */
-    lOldYInversion = GpiQueryYInversion (hps_begin_paint);
-    GpiEnableYInversion (hps_begin_paint, surface->bitmap_info.cy-1);
-
-    /* Debug code to draw rectangle limits */
-#if 0
-    {
-        int x, y;
-        unsigned char *pixels;
-
-        pixels = surface->pixels;
-        for (x = 0; x < surface->bitmap_info.cx; x++) {
-            for (y = 0; y < surface->bitmap_info.cy; y++) {
-                if ((x == 0) ||
-                    (y == 0) ||
-                    (x == y) ||
-                    (x >= surface->bitmap_info.cx-1) ||
-                    (y >= surface->bitmap_info.cy-1))
-                {
-                    pixels[y*surface->bitmap_info.cx*4+x*4] = 255;
-                }
+    inversion = GpiQueryYInversion (hps);
+    GpiEnableYInversion (hps, surface->height - 1);
+
+    for (ndx = 0; ndx < count; ndx++) {
+        POINTL  aPtl[4];
+
+        /* Change y values from OS/2's coordinate system to Cairo's;
+         * swap top & bottom to accommodate Y-inversion setting;
+         * and make the destination coordinates non-inclusive.
+         */
+        aPtl[0].x = dst[ndx].xLeft;
+        aPtl[0].y = surface->height - dst[ndx].yTop;
+        aPtl[1].x = dst[ndx].xRight - 1;
+        aPtl[1].y = surface->height - dst[ndx].yBottom - 1;
+
+        aPtl[2].x = src[ndx].xLeft;
+        aPtl[2].y = surface->height - src[ndx].yTop;
+        aPtl[3].x = src[ndx].xRight;
+        aPtl[3].y = surface->height - src[ndx].yBottom;
+
+        /* paint */
+        if (GpiDrawBits (hps, surface->data, &bmi,
+                         4, aPtl, ROP_SRCCOPY, BBO_IGNORE) != GPI_OK) {
+            status = _cairo_error (CAIRO_STATUS_DEVICE_ERROR);
+            break;
+        }
+    }
+
+    /* Restore Y inversion */
+    GpiEnableYInversion (hps, inversion);
+
+    return status;
+}
+
+
+/**
+ * _cairo_os2_surface_paint_24bpp:
+ * @surface: the cairo_os2_surface to display
+ * @hps: presentation space handle associated with the target device
+ * @src: an array of native RECTL structure identifying those areas of
+ *   the source surface which will be painted onto the destination
+ * @dst: an array of native RECTL structure that identify where on the
+ *   destination surface the corresponding @src rectangles will be painted
+ * @count: the number of RECTLs in @src and @dst arrays
+ *
+ * This is a fallback function used when the driver for the device context
+ * associated with @hps is unable to handle 32-bit bitmaps as input.  For
+ * each rectangle to be displayed, it copies that part of the surface to a
+ * temporary buffer, dropping the high-order byte to create a 24-bit bitmap.
+ *
+ * It temporarily enables Y-inversion for the presentation space so that
+ * Cairo's top-line-first bitmaps will be handled correctly.
+ *
+ * Returns: %CAIRO_STATUS_SUCCESS if successful,
+ *          %CAIRO_STATUS_DEVICE_ERROR if the bit-blit fails,
+ *          CAIRO_STATUS_NO_MEMORY if a buffer allocation fails.
+ *
+ * Since: 1.12
+ **/
+
+static cairo_status_t
+_cairo_os2_surface_paint_24bpp (cairo_os2_surface_t *surface,
+                                HPS                  hps,
+                                RECTL               *src,
+                                RECTL               *dst,
+                                int                  count)
+{
+    cairo_status_t status = CAIRO_STATUS_SUCCESS;
+    int            inversion;
+    int            ndx;
+    int            bufSize = 0;
+    unsigned char *pchBuffer = 0;
+    BITMAPINFO2    bmi;
+
+    /* Set up the bitmap header for 24bit depth. */
+    memset(&bmi, 0, sizeof (BITMAPINFO2));
+    bmi.cbFix = sizeof (BITMAPINFO2) - sizeof (bmi.argbColor[0]);
+    bmi.cPlanes = 1;
+    bmi.cBitCount = 24;
+
+    /* Enable Y Inversion for the HPS, so  GpiDrawBits will work with
+     * Cairo's top-line-first bitmap (vs OS/2's bottom-line-first bitmaps)
+     */
+    inversion = GpiQueryYInversion (hps);
+    GpiEnableYInversion (hps, surface->height - 1);
+
+    for (ndx = 0; ndx < count; ndx++) {
+
+        int             tgt_stride;
+        int             tgt_pad;
+        int             src_advance;
+        int             x_ctr;
+        int             y_ctr;
+        unsigned char  *pchTarget;
+        unsigned int   *pulSource;
+        POINTL          aPtl[4];
+
+        /* For the destination, change y values from OS/2's coordinate
+         * system to Cairo's;  swap top & bottom to accommodate the
+         * Y-inversion setting;  and make its coordinates non-inclusive.
+         */
+        aPtl[0].x = dst[ndx].xLeft;
+        aPtl[0].y = surface->height - dst[ndx].yTop;
+        aPtl[1].x = dst[ndx].xRight - 1;
+        aPtl[1].y = surface->height - dst[ndx].yBottom - 1;
+
+        /* For the source, calc its size and map its coordinates to
+         * the origin of the buffer that will contain the 24-bit data.
+         */
+        bmi.cx = src[ndx].xRight - src[ndx].xLeft;
+        bmi.cy = src[ndx].yTop - src[ndx].yBottom;
+        aPtl[2].x = 0;
+        aPtl[2].y = 0;
+        aPtl[3].x = bmi.cx;
+        aPtl[3].y = bmi.cy;
+
+        /* The start of each row has to be DWORD aligned.  For the 24-bit
+         * target bitmap, calculate the of number aligned bytes per row
+         * and the number of padding bytes at the end of each row.  For
+         * the 32-bit source bitmap, calc the number of bytes to advance
+         * to the starting position on its next row.
+         */
+        tgt_stride = (((bmi.cx * bmi.cBitCount) + 31) / 32) * 4;
+        tgt_pad = tgt_stride - bmi.cx * 3;
+        src_advance = surface->stride - bmi.cx * 4;
+
+        /* If the existing temporary bitmap buffer is large enough,
+         * reuse it;  otherwise, allocate a new one.  If the rows
+         * don't need padding, it has to be 1 byte larger than the
+         * size of the bitmap or else the high-order byte from the
+         * last source row will end up in unallocated memory.
+         */
+        x_ctr = tgt_stride * bmi.cy + (tgt_pad ? 0 : 1);
+        if (x_ctr > bufSize) {
+            bufSize = x_ctr;
+            if (pchBuffer)
+                _cairo_os2_surface_free (pchBuffer);
+            pchBuffer = _cairo_os2_surface_alloc (bufSize);
+            if (!pchBuffer) {
+                status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
+                break;
             }
         }
-    }
+
+        /* Calc the starting address in the source buffer. */
+        pulSource = (unsigned int*) (surface->data + (src[ndx].xLeft * 4) +
+                       ((surface->height - src[ndx].yTop) * surface->stride));
+
+        pchTarget = pchBuffer;
+
+        /* Copy 4 bytes from the source but advance the target ptr only
+         * 3 bytes, so the high-order alpha byte will be overwritten by
+         * the next copy. At the end of each row, skip over the padding.
+         */
+        for (y_ctr = bmi.cy; y_ctr; y_ctr--) {
+            for (x_ctr = bmi.cx; x_ctr; x_ctr--) {
+                *((unsigned int*)pchTarget) = *pulSource++;
+                pchTarget += 3;
+            }
+            pchTarget += tgt_pad;
+            pulSource  = (unsigned int*)((char*)pulSource + src_advance);
+        }
+
+        /* paint */
+        if (GpiDrawBits (hps, pchBuffer, &bmi,
+                         4, aPtl, ROP_SRCCOPY, BBO_IGNORE) != GPI_OK) {
+            status = _cairo_error (CAIRO_STATUS_DEVICE_ERROR);
+            break;
+        }
+    }
+
+    /* Free the temp buffer */
+    if (pchBuffer)
+        _cairo_os2_surface_free (pchBuffer);
+
+    /* Restore Y inversion */
+    GpiEnableYInversion (hps, inversion);
+
+    return status;
+}
+
+
+/**
+ * _cairo_os2_surface_paint_dive:
+ * @surface: the cairo_os2_surface to display
+ * @hps: presentation space handle associated with the target window
+ * @rect: an array of native RECTL structure identifying the bottom-left
+ *   and top-right corners of the areas to be displayed
+ * @count: the number RECTLs in @rect's array
+ *
+ * This function uses DIVE to write those portions of the surface identified
+ * by @rect directly to the screen buffer.  It only supports 32- or 24-bit
+ * full-color video modes.  To avoid painting overlapping or child windows,
+ * it must perform all of the visible-region calculations that GPI normally
+ * handles.  Despite this, it provides a significant improvement in speed
+ * compared to using GPI functions.
+ *
+ * Returns: %CAIRO_STATUS_SUCCESS if successful,
+ *          %CAIRO_STATUS_DEVICE_ERROR if any native call fails.
+ *
+ * Since: 1.12
+ **/
+
+static cairo_status_t
+_cairo_os2_surface_paint_dive (cairo_os2_surface_t *surface,
+                               HPS                  hps,
+                               RECTL               *rect,
+                               int                  count)
+{
+    cairo_status_t status = CAIRO_STATUS_DEVICE_ERROR;
+    int            rc;
+    int            ndx;
+    HRGN           rgnVisible = 0;
+    HRGN           rgnPaint = 0;
+    RGNRECT        rgnrect;
+    RECTL          rectWnd;
+    RECTL         *rectPtr;
+    RECTL         *rectPaint = 0;
+
+    /* Get the visible region for this window;  if not visible, exit. */
+    rgnVisible = GpiCreateRegion (hps, 0, 0);
+    if (!rgnVisible)
+        goto done;
+
+    rc = WinQueryVisibleRegion (surface->hwnd, rgnVisible);
+    if (rc == RGN_ERROR)
+        goto done;
+
+    if (rc == RGN_NULL) {
+        status = CAIRO_STATUS_SUCCESS;
+        goto done;
+    }
+
+    /* Create a region from the update rectangles, then AND it against the
+     * visible region to produce the series of rects that will be painted.
+     */
+    rgnPaint = GpiCreateRegion (hps, count, rect);
+    if (!rgnPaint)
+        goto done;
+
+    rc = GpiCombineRegion (hps, rgnVisible, rgnPaint, rgnVisible, CRGN_AND);
+    if (rc == RGN_ERROR)
+        goto done;
+
+    if (rc == RGN_NULL) {
+        status = CAIRO_STATUS_SUCCESS;
+        goto done;
+    }
+
+    /* Determine the number of rectangles to paint,
+     * allocate memory to store them, then fetch them.
+     */
+    rgnrect.ircStart = 1;
+    rgnrect.crc = (unsigned int)-1;
+    rgnrect.crcReturned = 0;
+    rgnrect.ulDirection = RECTDIR_LFRT_TOPBOT;
+
+    if (!GpiQueryRegionRects (hps, rgnVisible, 0, &rgnrect, 0))
+        goto done;
+
+    rectPaint = (RECTL*)malloc (rgnrect.crcReturned * sizeof(RECTL));
+    if (!rectPaint)
+        goto done;
+
+    rgnrect.crc = rgnrect.crcReturned;
+    rgnrect.crcReturned = 0;
+    if (!GpiQueryRegionRects (hps, rgnVisible, 0, &rgnrect, rectPaint))
+        goto done;
+
+    /* Get the window's position in screen coordinates. */
+    WinQueryWindowRect (surface->hwnd, &rectWnd);
+    WinMapWindowPoints (surface->hwnd, HWND_DESKTOP, (POINTL*)&rectWnd, 2);
+
+    /* If required by the video driver, hide the mouse pointer. */
+    if (dive_hideptr)
+        WinShowPointer (HWND_DESKTOP, FALSE);
+
+    /* Get access to the frame buffer */
+    rc = DiveAcquireFrameBuffer (dive_handle, &rectWnd);
+    if (rc) {
+        _cairo_os2_surface_dive_error ();
+        goto done;
+    }
+
+    for (ndx = rgnrect.crcReturned, rectPtr = rectPaint; ndx; ndx--, rectPtr++) {
+        int            x;
+        int            y;
+        unsigned char *srcPtr;
+        unsigned char *dstPtr;
+
+        /* Get the starting point in the surface's buffer. */
+        x = rectPtr->xLeft;
+        y = surface->height - rectPtr->yTop;
+        srcPtr = surface->data + (y * surface->stride) + (x * 4);
+
+        /* Get the starting point in the frame buffer. */
+        x = rectPtr->xLeft + rectWnd.xLeft;
+        y = dive_height - (rectPtr->yTop + rectWnd.yBottom);
+        dstPtr = dive_scrnbuf + (y * dive_stride) +
+                 (x * (display_use24bpp ? 3 : 4));
+
+        x = (rectPtr->xRight - rectPtr->xLeft);
+        y = rectPtr->yTop - rectPtr->yBottom;
+
+        /* For 24-bit mode, copy 3 bytes at a time but move the source
+         * pointer 4 bytes to skip over the alpha byte.  when we reach
+         * the right edge of the rect, advance each ptr by the stride
+         * minus the distance they've already advanced.
+         */
+        if (unlikely (display_use24bpp)) {
+            int   ndx;
+            int   srcAdvance = surface->stride - (x * 4);
+            int   dstAdvance = dive_stride - (x * 3);
+
+            while (y) {
+                for (ndx = x; ndx; ndx--) {
+                    memcpy (dstPtr, srcPtr, 3);
+                    srcPtr += 4;
+                    dstPtr += 3;
+                }
+                srcPtr += srcAdvance;
+                dstPtr += dstAdvance;;
+                y--;
+            }
+        } else {
+            /* For 32-bit mode, copy an entire line at a time,
+             * then advance each pointer by its respective stride.
+             */
+            x *= 4;
+            while (y) {
+                memcpy (dstPtr, srcPtr, x);
+                srcPtr += surface->stride;
+                dstPtr += dive_stride;
+                y--;
+            }
+        }
+    }
+
+    /* Release the frame buffer */
+    rc = DiveDeacquireFrameBuffer (dive_handle);
+    if (rc) {
+        _cairo_os2_surface_dive_error ();
+        goto done;
+    }
+
+    status = CAIRO_STATUS_SUCCESS;
+
+done:
+    /* Cleanup */
+    if (dive_hideptr)
+        WinShowPointer (HWND_DESKTOP, TRUE);
+    if (rectPaint)
+        free (rectPaint);
+    if (rgnPaint)
+        GpiDestroyRegion (hps, rgnPaint);
+    if (rgnVisible)
+        GpiDestroyRegion (hps, rgnVisible);
+
+    return status;
+}
+
+
+/**
+ * _cairo_os2_surface_dive_error:
+ *
+ * Closes DIVE instance if open, resets values, and disables DIVE
+ * for this process.  Used when a DIVE function fails.
+ *
+ * Returns: no return value.
+ *
+ * Since: 1.12
+ **/
+
+static void
+_cairo_os2_surface_dive_error (void)
+{
+    if (dive_handle)
+        DiveClose (dive_handle);
+    dive_handle = 0;
+    dive_scrnbuf = 0;
+    dive_hideptr = TRUE;
+    dive_status = -1;
+    return;
+}
+
+
+/**
+ * _cairo_os2_surface_load_dive:
+ *
+ * Loads dive.dll and gets the entry point addresses used by this module.
+ *
+ * Returns: %TRUE if successful, %FALSE otherwise.
+ *
+ * Since: 1.12
+ **/
+
+#ifdef OS2_DYNAMIC_DIVE
+
+static cairo_bool_t
+_cairo_os2_surface_load_dive (void)
+{
+    HMODULE hmod;
+
+    if (DosLoadModule (0, 0, "DIVE", &hmod))
+        return FALSE;
+
+    if (DosQueryProcAddr (hmod, ORD_DIVEQUERYCAPS,
+                          0,    (PFN*)&pDiveQueryCaps) ||
+        DosQueryProcAddr (hmod, ORD_DIVEOPEN,
+                          0,    (PFN*)&pDiveOpen) ||
+        DosQueryProcAddr (hmod, ORD_DIVECLOSE,
+                          0,    (PFN*)&pDiveClose) ||
+        DosQueryProcAddr (hmod, ORD_DIVEACQUIREFRAMEBUFFER,
+                          0,    (PFN*)&pDiveAcquireFrameBuffer) ||
+        DosQueryProcAddr (hmod, ORD_DIVEDEACQUIREFRAMEBUFFER,
+                          0,    (PFN*)&pDiveDeacquireFrameBuffer)) {
+        DosFreeModule(hmod);
+        return FALSE;
+    }
+
+    return TRUE;
+}
 #endif
-    if (!surface->use_24bpp) {
-        rc = GpiDrawBits (hps_begin_paint,
-                          surface->pixels,
-                          &(surface->bitmap_info),
-                          4,
-                          aptlPoints,
-                          ROP_SRCCOPY,
-                          BBO_IGNORE);
-        if (rc != GPI_OK)
-            surface->use_24bpp = TRUE;
-    }
-
-    if (surface->use_24bpp) {
-        /* If GpiDrawBits () failed then this is most likely because the
-         * display driver could not handle a 32bit bitmap. So we need to
-         * - create a buffer that only contains 3 bytes per pixel
-         * - change the bitmap info header to contain 24bit
-         * - pass the new buffer to GpiDrawBits () again
-         * - clean up the new buffer
-         */
-        BITMAPINFO2       bmpinfo;
-        unsigned char    *pchPixBuf;
-        unsigned char    *pchTarget;
-        ULONG            *pulSource;
-        ULONG             ulX;
-        ULONG             ulY;
-        ULONG             ulPad;
-
-        /* Set up the bitmap header, but this time for 24bit depth. */
-        bmpinfo = surface->bitmap_info;
-        bmpinfo.cBitCount = 24;
-
-        /* The start of each row has to be DWORD aligned.  Calculate the
-         * of number aligned bytes per row, the total size of the bitmap,
-         * and the number of padding bytes at the end of each row.
-         */
-        ulX = (((bmpinfo.cx * bmpinfo.cBitCount) + 31) / 32) * 4;
-        bmpinfo.cbImage = ulX * bmpinfo.cy;
-        ulPad = ulX - bmpinfo.cx * 3;
-
-        /* Allocate temporary pixel buffer.  If the rows don't need
-         * padding, it has to be 1 byte larger than the size of the
-         * bitmap  or else the high-order byte from the last source
-         * row will end up in unallocated memory.
-         */
-        pchPixBuf = (unsigned char *)_buffer_alloc (1, 1,
-                                        bmpinfo.cbImage + (ulPad ? 0 : 1));
-
-        if (pchPixBuf) {
-            /* Copy 4 bytes from the source but advance the target ptr only
-             * 3 bytes, so the high-order alpha byte will be overwritten by
-             * the next copy. At the end of each row, skip over the padding.
-             */
-            pchTarget = pchPixBuf;
-            pulSource = (ULONG*)surface->pixels;
-            for (ulY = bmpinfo.cy; ulY; ulY--) {
-                for (ulX = bmpinfo.cx; ulX; ulX--) {
-                    *((ULONG*)pchTarget) = *pulSource++;
-                    pchTarget += 3;
-                }
-                pchTarget += ulPad;
-            }
-
-            rc = GpiDrawBits (hps_begin_paint,
-                              pchPixBuf,
-                              &bmpinfo,
-                              4,
-                              aptlPoints,
-                              ROP_SRCCOPY,
-                              BBO_IGNORE);
-            if (rc != GPI_OK)
-                surface->use_24bpp = FALSE;
-
-            _buffer_free (pchPixBuf);
-        }
-    }
-
-    /* Restore Y inversion */
-    GpiEnableYInversion (hps_begin_paint, lOldYInversion);
-}
-
-static void
-_cairo_os2_surface_get_pixels_from_screen (cairo_os2_surface_t *surface,
-                                           HPS                  hps_begin_paint,
-                                           PRECTL               prcl_begin_paint_rect)
-{
-    HPS hps;
-    HDC hdc;
-    SIZEL sizlTemp;
-    HBITMAP hbmpTemp;
-    BITMAPINFO2 bmi2Temp;
-    POINTL aptlPoints[4];
-    int y;
-    unsigned char *pchTemp;
-
-    /* To copy pixels from screen to our buffer, we do the following steps:
-     *
-     * - Blit pixels from screen to a HBITMAP:
-     *   -- Create Memory Device Context
-     *   -- Create a PS into it
-     *   -- Create a HBITMAP
-     *   -- Select HBITMAP into memory PS
-     *   -- Blit dirty pixels from screen to HBITMAP
-     * - Copy HBITMAP lines (pixels) into our buffer
-     * - Free resources
-     */
-
-    /* Create a memory device context */
-    hdc = DevOpenDC (0, OD_MEMORY,"*",0L, NULL, NULLHANDLE);
-    if (!hdc) {
-        return;
-    }
-
-    /* Create a memory PS */
-    sizlTemp.cx = prcl_begin_paint_rect->xRight - prcl_begin_paint_rect->xLeft;
-    sizlTemp.cy = prcl_begin_paint_rect->yTop - prcl_begin_paint_rect->yBottom;
-    hps = GpiCreatePS (0,
-                       hdc,
-                       &sizlTemp,
-                       PU_PELS | GPIT_NORMAL | GPIA_ASSOC);
-    if (!hps) {
-        DevCloseDC (hdc);
-        return;
-    }
-
-    /* Create an uninitialized bitmap. */
-    /* Prepare BITMAPINFO2 structure for our buffer */
-    memset (&bmi2Temp, 0, sizeof (bmi2Temp));
-    bmi2Temp.cbFix = sizeof (BITMAPINFOHEADER2);
-    bmi2Temp.cx = sizlTemp.cx;
-    bmi2Temp.cy = sizlTemp.cy;
-    bmi2Temp.cPlanes = 1;
-    bmi2Temp.cBitCount = 32;
-
-    hbmpTemp = GpiCreateBitmap (hps,
-                                (PBITMAPINFOHEADER2) &bmi2Temp,
-                                0,
-                                NULL,
-                                NULL);
-
-    if (!hbmpTemp) {
-        GpiDestroyPS (hps);
-        DevCloseDC (hdc);
-        return;
-    }
-
-    /* Select the bitmap into the memory device context. */
-    GpiSetBitmap (hps, hbmpTemp);
-
-    /* Target coordinates (Noninclusive) */
-    aptlPoints[0].x = 0;
-    aptlPoints[0].y = 0;
-
-    aptlPoints[1].x = sizlTemp.cx;
-    aptlPoints[1].y = sizlTemp.cy;
-
-    /* Source coordinates (Inclusive) */
-    aptlPoints[2].x = prcl_begin_paint_rect->xLeft;
-    aptlPoints[2].y = surface->bitmap_info.cy - prcl_begin_paint_rect->yBottom;
-
-    aptlPoints[3].x = prcl_begin_paint_rect->xRight;
-    aptlPoints[3].y = surface->bitmap_info.cy - prcl_begin_paint_rect->yTop;
-
-    /* Blit pixels from screen to bitmap */
-    GpiBitBlt (hps,
-               hps_begin_paint,
-               4,
-               aptlPoints,
-               ROP_SRCCOPY,
-               BBO_IGNORE);
-
-    /* Now we have to extract the pixels from the bitmap. */
-    pchTemp =
-        surface->pixels +
-        (prcl_begin_paint_rect->yBottom)*surface->bitmap_info.cx*4 +
-        prcl_begin_paint_rect->xLeft*4;
-    for (y = 0; y < sizlTemp.cy; y++) {
-        /* Get one line of pixels */
-        GpiQueryBitmapBits (hps,
-                            sizlTemp.cy - y - 1, /* lScanStart */
-                            1,                   /* lScans */
-                            (PBYTE)pchTemp,
-                            &bmi2Temp);
-
-        /* Go for next line */
-        pchTemp += surface->bitmap_info.cx*4;
-    }
-
-    /* Clean up resources */
-    GpiSetBitmap (hps, (HBITMAP) NULL);
-    GpiDeleteBitmap (hbmpTemp);
-    GpiDestroyPS (hps);
-    DevCloseDC (hdc);
-}
-
-static cairo_status_t
-_cairo_os2_surface_acquire_source_image (void                   *abstract_surface,
-                                         cairo_image_surface_t **image_out,
-                                         void                  **image_extra)
-{
-    cairo_os2_surface_t *surface = (cairo_os2_surface_t *) abstract_surface;
-
-    DosRequestMutexSem (surface->hmtx_use_private_fields, SEM_INDEFINITE_WAIT);
-
-    /* Increase lend counter */
-    surface->pixel_array_lend_count++;
-
-    *image_out = surface->image_surface;
-    *image_extra = NULL;
-
-    DosReleaseMutexSem (surface->hmtx_use_private_fields);
-
-    return CAIRO_STATUS_SUCCESS;
-}
-
-static void
-_cairo_os2_surface_release_source_image (void                  *abstract_surface,
-                                         cairo_image_surface_t *image,
-                                         void                  *image_extra)
-{
-    cairo_os2_surface_t *surface = (cairo_os2_surface_t *) abstract_surface;
-
-    /* Decrease Lend counter! */
-    DosRequestMutexSem (surface->hmtx_use_private_fields, SEM_INDEFINITE_WAIT);
-
-    if (surface->pixel_array_lend_count > 0)
-        surface->pixel_array_lend_count--;
-    DosPostEventSem (surface->hev_pixel_array_came_back);
-
-    DosReleaseMutexSem (surface->hmtx_use_private_fields);
-}
-
-static cairo_surface_t *
-_cairo_os2_surface_map_to_image (void *abstract_surface,
-                                 const cairo_rectangle_int_t *extents)
-{
-    cairo_os2_surface_t *surface = (cairo_os2_surface_t *) abstract_surface;
-
-    DosRequestMutexSem (surface->hmtx_use_private_fields, SEM_INDEFINITE_WAIT);
-    /* Increase lend counter */
-    surface->pixel_array_lend_count++;
-    DosReleaseMutexSem (surface->hmtx_use_private_fields);
-
-    return _cairo_surface_create_for_rectangle_int (surface->image_surface,
-                                                    extents);
-}
-
-static cairo_int_status_t
-_cairo_os2_surface_unmap_image (void *abstract_surface,
-                                cairo_image_surface_t *image)
-{
-    cairo_os2_surface_t *surface = (cairo_os2_surface_t *) abstract_surface;
-
-    /* So, we got back the image, and if all goes well, then
-     * something has been changed inside the interest_rect.
-     * So, we blit it to the screen!
-     */
-    if (surface->blit_as_changes) {
-        RECTL rclToBlit;
-
-        /* Get mutex, we'll work with the pixel array! */
-        if (DosRequestMutexSem (surface->hmtx_use_private_fields,
-                                SEM_INDEFINITE_WAIT) != NO_ERROR)
-        {
-            /* Could not get mutex! */
-            return;
-        }
-
-        rclToBlit.xLeft = image->base.device_transform_inverse.x0;
-        rclToBlit.xRight = rclToBlit.xLeft + image->width; /* Noninclusive */
-        rclToBlit.yTop = image->base.device_transform_inverse.y0;
-        rclToBlit.yBottom = rclToBlit.yTop + image->height; /* Noninclusive */
-
-        if (surface->hwnd_client_window) {
-            /* We know the HWND, so let's invalidate the window region,
-             * so the application will redraw itself, using the
-             * cairo_os2_surface_refresh_window () API from its own PM thread.
-             *
-             * This is the safe method, which should be preferred every time.
-             */
-            rclToBlit.yTop = surface->bitmap_info.cy - rclToBlit.yTop;
-            rclToBlit.yBottom = surface->bitmap_info.cy - rclToBlit.yTop;
-            WinInvalidateRect (surface->hwnd_client_window,
-                               &rclToBlit,
-                               FALSE);
-        } else {
-            /* We don't know the HWND, so try to blit the pixels from here!
-             * Please note that it can be problematic if this is not the PM thread!
-             *
-             * It can cause internal PM stuffs to be screwed up, for some reason.
-             * Please always tell the HWND to the surface using the
-             * cairo_os2_surface_set_hwnd () API, and call cairo_os2_surface_refresh_window ()
-             * from your WM_PAINT, if it's possible!
-             */
-            _cairo_os2_surface_blit_pixels (surface,
-                                            surface->hps_client_window,
-                                            &rclToBlit);
-        }
-
-        DosReleaseMutexSem (surface->hmtx_use_private_fields);
-    }
-    /* Also decrease Lend counter! */
-    DosRequestMutexSem (surface->hmtx_use_private_fields, SEM_INDEFINITE_WAIT);
-
-    if (surface->pixel_array_lend_count > 0)
-        surface->pixel_array_lend_count--;
-    DosPostEventSem (surface->hev_pixel_array_came_back);
-
-    DosReleaseMutexSem (surface->hmtx_use_private_fields);
-}
-
-static cairo_bool_t
-_cairo_os2_surface_get_extents (void                    *abstract_surface,
-                                cairo_rectangle_int_t   *rectangle)
-{
-    cairo_os2_surface_t *surface = (cairo_os2_surface_t *) abstract_surface;
-
-    rectangle->x = 0;
-    rectangle->y = 0;
-    rectangle->width  = surface->bitmap_info.cx;
-    rectangle->height = surface->bitmap_info.cy;
-
-    return TRUE;
-}
-
-/**
- * cairo_os2_surface_create:
- * @hps_client_window: the presentation handle to bind the surface to
- * @width: the width of the surface
- * @height: the height of the surface
- *
- * Create a Cairo surface which is bound to a given presentation space (HPS).
- * The caller retains ownership of the HPS and must dispose of it after the
- * the surface has been destroyed.  The surface will be created to have the
- * given size. By default every change to the surface will be made visible
- * immediately by blitting it into the window. This can be changed with
- * cairo_os2_surface_set_manual_window_refresh().
- * Note that the surface will contain garbage when created, so the pixels
- * have to be initialized by hand first. You can use the Cairo functions to
- * fill it with black, or use cairo_surface_mark_dirty() to fill the surface
- * with pixels from the window/HPS.
- *
- * Return value: the newly created surface
- *
- * Since: 1.4
- **/
-cairo_surface_t *
-cairo_os2_surface_create (HPS hps_client_window,
-                          int width,
-                          int height)
-{
-    cairo_os2_surface_t *local_os2_surface = 0;
-    cairo_status_t status;
-    int rc;
-
-    /* Check the size of the window */
-    if ((width <= 0) || (height <= 0)) {
-        status = _cairo_error (CAIRO_STATUS_INVALID_SIZE);
-        goto error_exit;
-    }
-
-    /* Allocate an OS/2 surface structure. */
-    local_os2_surface = (cairo_os2_surface_t *) malloc (sizeof (cairo_os2_surface_t));
-    if (!local_os2_surface) {
-        status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
-        goto error_exit;
-    }
-
-    memset(local_os2_surface, 0, sizeof(cairo_os2_surface_t));
-
-    /* Allocate resources:  mutex & event semaphores and the pixel buffer */
-    if (DosCreateMutexSem (NULL,
-                           &(local_os2_surface->hmtx_use_private_fields),
-                           0,
-                           FALSE))
-    {
-        status = _cairo_error (CAIRO_STATUS_DEVICE_ERROR);
-        goto error_exit;
-    }
-
-    if (DosCreateEventSem (NULL,
-                           &(local_os2_surface->hev_pixel_array_came_back),
-                           0,
-                           FALSE))
-    {
-        status = _cairo_error (CAIRO_STATUS_DEVICE_ERROR);
-        goto error_exit;
-    }
-
-    local_os2_surface->pixels = (unsigned char *) _buffer_alloc (height, width, 4);
-    if (!local_os2_surface->pixels) {
-        status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
-        goto error_exit;
-    }
-
-    /* Create image surface from pixel array */
-    local_os2_surface->image_surface = (cairo_image_surface_t *)
-        cairo_image_surface_create_for_data (local_os2_surface->pixels,
-                                             CAIRO_FORMAT_ARGB32,
-                                             width,      /* Width */
-                                             height,     /* Height */
-                                             width * 4); /* Rowstride */
-    status = local_os2_surface->image_surface->base.status;
-    if (status)
-        goto error_exit;
-
-    /* Set values for OS/2-specific data that aren't zero/NULL/FALSE.
-     * Note: hps_client_window may be null if this was called by
-     * cairo_os2_surface_create_for_window().
-     */
-    local_os2_surface->hps_client_window = hps_client_window;
-    local_os2_surface->blit_as_changes = TRUE;
-
-    /* Prepare BITMAPINFO2 structure for our buffer */
-    local_os2_surface->bitmap_info.cbFix = sizeof (BITMAPINFOHEADER2);
-    local_os2_surface->bitmap_info.cx = width;
-    local_os2_surface->bitmap_info.cy = height;
-    local_os2_surface->bitmap_info.cPlanes = 1;
-    local_os2_surface->bitmap_info.cBitCount = 32;
-
-    /* Initialize base surface */
-    _cairo_surface_init (&local_os2_surface->base,
-                         &cairo_os2_surface_backend,
-                         NULL, /* device */
-                         _cairo_content_from_format (CAIRO_FORMAT_ARGB32));
-
-    /* Successful exit */
-    return (cairo_surface_t *)local_os2_surface;
-
- error_exit:
-
-    /* This point will only be reached if an error occurred */
-
-    if (local_os2_surface) {
-        if (local_os2_surface->pixels)
-            _buffer_free (local_os2_surface->pixels);
-        if (local_os2_surface->hev_pixel_array_came_back)
-            DosCloseEventSem (local_os2_surface->hev_pixel_array_came_back);
-        if (local_os2_surface->hmtx_use_private_fields)
-            DosCloseMutexSem (local_os2_surface->hmtx_use_private_fields);
-        free (local_os2_surface);
-    }
-
-    return _cairo_surface_create_in_error (status);
-}
-
-/**
- * cairo_os2_surface_create_for_window:
- * @hwnd_client_window: the window handle to bind the surface to
- * @width: the width of the surface
- * @height: the height of the surface
- *
- * Create a Cairo surface which is bound to a given window; the caller retains
- * ownership of the window.  This is a convenience function for use with
- * windows that will only be updated when cairo_os2_surface_refresh_window()
- * is called (usually in response to a WM_PAINT message).  It avoids the need
- * to create a persistent HPS for every window and assumes that one will be
- * supplied by the caller when a cairo function needs one.  If it isn't, an
- * HPS will be created on-the-fly and released before the function which needs
- * it returns.
- *
- * Return value: the newly created surface
- *
- * Since: 1.10
- **/
-cairo_surface_t *
-cairo_os2_surface_create_for_window (HWND hwnd_client_window,
-                                     int width,
-                                     int height)
-{
-    cairo_os2_surface_t *local_os2_surface;
-
-    /* A window handle must be provided. */
-    if (!hwnd_client_window) {
-        return _cairo_surface_create_in_error (
-                                _cairo_error (CAIRO_STATUS_NO_MEMORY));
-    }
-
-    /* Create the surface. */
-    local_os2_surface = (cairo_os2_surface_t *)
-        cairo_os2_surface_create (0, width, height);
-
-    /* If successful, save the hwnd & turn off automatic repainting. */
-    if (!local_os2_surface->image_surface->base.status) {
-        local_os2_surface->hwnd_client_window = hwnd_client_window;
-        local_os2_surface->blit_as_changes = FALSE;
-    }
-
-    return (cairo_surface_t *)local_os2_surface;
-}
-
-/**
- * cairo_os2_surface_set_size:
- * @surface: the cairo surface to resize
- * @new_width: the new width of the surface
- * @new_height: the new height of the surface
- * @timeout: timeout value in milliseconds
- *
- * When the client window is resized, call this API to set the new size in the
- * underlying surface accordingly. This function will reallocate everything,
- * so you'll have to redraw everything in the surface after this call.
- * The surface will contain garbage after the resizing. So the notes of
- * cairo_os2_surface_create() apply here, too.
- *
- * The timeout value specifies how long the function should wait on other parts
- * of the program to release the buffers. It is necessary, because it can happen
- * that Cairo is just drawing something into the surface while we want to
- * destroy and recreate it.
- *
- * Return value: %CAIRO_STATUS_SUCCESS if the surface could be resized,
- * %CAIRO_STATUS_SURFACE_TYPE_MISMATCH if the surface is not an OS/2 surface,
- * %CAIRO_STATUS_INVALID_SIZE for invalid sizes
- * %CAIRO_STATUS_NO_MEMORY if the new size could not be allocated, or if the
- * timeout happened before all the buffers were released
- *
- * Since: 1.4
- **/
-int
-cairo_os2_surface_set_size (cairo_surface_t *surface,
-                            int              new_width,
-                            int              new_height,
-                            int              timeout)
-{
-    cairo_os2_surface_t *local_os2_surface;
-    unsigned char *pchNewPixels;
-    int rc;
-    cairo_image_surface_t *pNewImageSurface;
-
-    local_os2_surface = (cairo_os2_surface_t *) surface;
-    if ((!local_os2_surface) ||
-        (local_os2_surface->base.backend != &cairo_os2_surface_backend))
-    {
-        /* Invalid parameter (wrong surface)! */
-        return _cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH);
-    }
-
-    if ((new_width <= 0) ||
-        (new_height <= 0))
-    {
-        /* Invalid size! */
-        return _cairo_error (CAIRO_STATUS_INVALID_SIZE);
-    }
-
-    /* Allocate memory for new stuffs */
-    pchNewPixels = (unsigned char *) _buffer_alloc (new_height, new_width, 4);
-    if (!pchNewPixels) {
-        /* Not enough memory for the pixels!
-         * Everything remains the same!
-         */
-        return _cairo_error (CAIRO_STATUS_NO_MEMORY);
-    }
-
-    /* Create image surface from new pixel array */
-    pNewImageSurface = (cairo_image_surface_t *)
-        cairo_image_surface_create_for_data (pchNewPixels,
-                                             CAIRO_FORMAT_ARGB32,
-                                             new_width,      /* Width */
-                                             new_height,     /* Height */
-                                             new_width * 4); /* Rowstride */
-
-    if (pNewImageSurface->base.status) {
-        /* Could not create image surface!
-         * Everything remains the same!
-         */
-        _buffer_free (pchNewPixels);
-        return _cairo_error (CAIRO_STATUS_NO_MEMORY);
-    }
-
-    /* Okay, new memory allocated, so it's time to swap old buffers
-     * to new ones!
-     */
-    if (DosRequestMutexSem (local_os2_surface->hmtx_use_private_fields, SEM_INDEFINITE_WAIT)!=NO_ERROR) {
-        /* Could not get mutex!
-         * Everything remains the same!
-         */
-        cairo_surface_destroy ((cairo_surface_t *) pNewImageSurface);
-        _buffer_free (pchNewPixels);
-        return _cairo_error (CAIRO_STATUS_NO_MEMORY);
-    }
-
-    /* We have to make sure that we won't destroy a surface which
-     * is lent to some other code (Cairo is drawing into it)!
-     */
-    while (local_os2_surface->pixel_array_lend_count > 0) {
-        ULONG ulPostCount;
-        DosResetEventSem (local_os2_surface->hev_pixel_array_came_back, &ulPostCount);
-        DosReleaseMutexSem (local_os2_surface->hmtx_use_private_fields);
-        /* Wait for somebody to return the pixels! */
-        rc = DosWaitEventSem (local_os2_surface->hev_pixel_array_came_back, timeout);
-        if (rc != NO_ERROR) {
-            /* Either timeout or something wrong... Exit. */
-            cairo_surface_destroy ((cairo_surface_t *) pNewImageSurface);
-            _buffer_free (pchNewPixels);
-            return _cairo_error (CAIRO_STATUS_NO_MEMORY);
-        }
-        /* Okay, grab mutex and check counter again! */
-        if (DosRequestMutexSem (local_os2_surface->hmtx_use_private_fields, SEM_INDEFINITE_WAIT)
-            != NO_ERROR)
-        {
-            /* Could not get mutex!
-             * Everything remains the same!
-             */
-            cairo_surface_destroy ((cairo_surface_t *) pNewImageSurface);
-            _buffer_free (pchNewPixels);
-            return _cairo_error (CAIRO_STATUS_NO_MEMORY);
-        }
-    }
-
-    /* Destroy old image surface */
-    cairo_surface_destroy ((cairo_surface_t *) (local_os2_surface->image_surface));
-    /* Destroy old pixel buffer */
-    _buffer_free (local_os2_surface->pixels);
-    /* Set new image surface */
-    local_os2_surface->image_surface = pNewImageSurface;
-    /* Set new pixel buffer */
-    local_os2_surface->pixels = pchNewPixels;
-    /* Change bitmap2 structure */
-    local_os2_surface->bitmap_info.cx = new_width;
-    local_os2_surface->bitmap_info.cy = new_height;
-
-    DosReleaseMutexSem (local_os2_surface->hmtx_use_private_fields);
-    return CAIRO_STATUS_SUCCESS;
-}
-
-/**
- * cairo_os2_surface_refresh_window:
- * @surface: the cairo surface to refresh
- * @hps_begin_paint: the presentation handle of the window to refresh
- * @prcl_begin_paint_rect: the rectangle to redraw
- *
- * This function can be used to force a repaint of a given area of the client
- * window. It should usually be called from the WM_PAINT processing of the
- * window procedure. However, it can be called any time a given part of the
- * window has to be updated.
- *
- * The HPS and RECTL to be passed can be taken from the usual WinBeginPaint call
- * of the window procedure, but you can also get the HPS using WinGetPS, and you
- * can assemble your own update rectangle by hand.
- * If hps_begin_paint is %NULL, the function will use the HPS passed into
- * cairo_os2_surface_create(). If @prcl_begin_paint_rect is %NULL, the function
- * will query the current window size and repaint the whole window.
- *
- * Cairo assumes that if you set the HWND to the surface using
- * cairo_os2_surface_set_hwnd(), this function will be called by the application
- * every time it gets a WM_PAINT for that HWND. If the HWND is set in the
- * surface, Cairo uses this function to handle dirty areas too.
- *
- * Since: 1.4
- **/
-void
-cairo_os2_surface_refresh_window (cairo_surface_t *surface,
-                                  HPS              hps_begin_paint,
-                                  PRECTL           prcl_begin_paint_rect)
-{
-    cairo_os2_surface_t *local_os2_surface;
-    RECTL rclTemp;
-    HPS hpsTemp = 0;
-
-    local_os2_surface = (cairo_os2_surface_t *) surface;
-    if ((!local_os2_surface) ||
-        (local_os2_surface->base.backend != &cairo_os2_surface_backend))
-    {
-        /* Invalid parameter (wrong surface)! */
-        return;
-    }
-
-    /* If an HPS wasn't provided, see if we can get one. */
-    if (!hps_begin_paint) {
-        hps_begin_paint = local_os2_surface->hps_client_window;
-        if (!hps_begin_paint) {
-            if (local_os2_surface->hwnd_client_window) {
-                hpsTemp = WinGetPS(local_os2_surface->hwnd_client_window);
-                hps_begin_paint = hpsTemp;
-            }
-            /* No HPS & no way to get one, so exit */
-            if (!hps_begin_paint)
-                return;
-        }
-    }
-
-    if (prcl_begin_paint_rect == NULL) {
-        /* Update the whole window! */
-        rclTemp.xLeft = 0;
-        rclTemp.xRight = local_os2_surface->bitmap_info.cx;
-        rclTemp.yTop = local_os2_surface->bitmap_info.cy;
-        rclTemp.yBottom = 0;
-    } else {
-        /* Use the rectangle we got passed as parameter! */
-        rclTemp.xLeft = prcl_begin_paint_rect->xLeft;
-        rclTemp.xRight = prcl_begin_paint_rect->xRight;
-        rclTemp.yTop = local_os2_surface->bitmap_info.cy - prcl_begin_paint_rect->yBottom;
-        rclTemp.yBottom = local_os2_surface->bitmap_info.cy - prcl_begin_paint_rect->yTop ;
-    }
-
-    /* Get mutex, we'll work with the pixel array! */
-    if (DosRequestMutexSem (local_os2_surface->hmtx_use_private_fields, SEM_INDEFINITE_WAIT)
-        != NO_ERROR)
-    {
-        /* Could not get mutex! */
-        if (hpsTemp)
-            WinReleasePS(hpsTemp);
-        return;
-    }
-
-    if ((local_os2_surface->dirty_area_present) &&
-        (local_os2_surface->rcl_dirty_area.xLeft == rclTemp.xLeft) &&
-        (local_os2_surface->rcl_dirty_area.xRight == rclTemp.xRight) &&
-        (local_os2_surface->rcl_dirty_area.yTop == rclTemp.yTop) &&
-        (local_os2_surface->rcl_dirty_area.yBottom == rclTemp.yBottom))
-    {
-        /* Aha, this call was because of a dirty area, so in this case we
-         * have to blit the pixels from the screen to the surface!
-         */
-        local_os2_surface->dirty_area_present = FALSE;
-        _cairo_os2_surface_get_pixels_from_screen (local_os2_surface,
-                                                   hps_begin_paint,
-                                                   &rclTemp);
-    } else {
-        /* Okay, we have the surface, have the HPS
-         * (might be from WinBeginPaint () or from WinGetPS () )
-         * Now blit there the stuffs!
-         */
-        _cairo_os2_surface_blit_pixels (local_os2_surface,
-                                        hps_begin_paint,
-                                        &rclTemp);
-    }
-
-    DosReleaseMutexSem (local_os2_surface->hmtx_use_private_fields);
-
-    if (hpsTemp)
-        WinReleasePS(hpsTemp);
-}
-
-static cairo_status_t
-_cairo_os2_surface_finish (void *abstract_surface)
-{
-    cairo_os2_surface_t *local_os2_surface;
-
-    local_os2_surface = (cairo_os2_surface_t *) abstract_surface;
-    if ((!local_os2_surface) ||
-        (local_os2_surface->base.backend != &cairo_os2_surface_backend))
-    {
-        /* Invalid parameter (wrong surface)! */
-        return _cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH);
-    }
-
-    DosRequestMutexSem (local_os2_surface->hmtx_use_private_fields, SEM_INDEFINITE_WAIT);
-
-    /* Destroy old image surface */
-    cairo_surface_destroy ((cairo_surface_t *) (local_os2_surface->image_surface));
-    /* Destroy old pixel buffer */
-    _buffer_free (local_os2_surface->pixels);
-    DosCloseMutexSem (local_os2_surface->hmtx_use_private_fields);
-    DosCloseEventSem (local_os2_surface->hev_pixel_array_came_back);
-
-    /* The memory itself will be free'd by the cairo_surface_destroy ()
-     * who called us.
-     */
-
-    return CAIRO_STATUS_SUCCESS;
-}
-
-/**
- * cairo_os2_surface_set_hwnd:
- * @surface: the cairo surface to associate with the window handle
- * @hwnd_client_window: the window handle of the client window
- *
- * Sets window handle for surface; the caller retains ownership of the window.
- * If Cairo wants to blit into the window because it is set to blit as the
- * surface changes (see cairo_os2_surface_set_manual_window_refresh()), then
- * there are two ways it can choose:
- * If it knows the HWND of the surface, then it invalidates that area, so the
- * application will get a WM_PAINT message and it can call
- * cairo_os2_surface_refresh_window() to redraw that area. Otherwise cairo itself
- * will use the HPS it got at surface creation time, and blit the pixels itself.
- * It's also a solution, but experience shows that if this happens from a non-PM
- * thread, then it can screw up PM internals.
- *
- * So, best solution is to set the HWND for the surface after the surface
- * creation, so every blit will be done from application's message processing
- * loop, which is the safest way to do.
- *
- * Since: 1.4
- **/
-void
-cairo_os2_surface_set_hwnd (cairo_surface_t *surface,
-                            HWND             hwnd_client_window)
-{
-    cairo_os2_surface_t *local_os2_surface;
-
-    local_os2_surface = (cairo_os2_surface_t *) surface;
-    if ((!local_os2_surface) ||
-        (local_os2_surface->base.backend != &cairo_os2_surface_backend))
-    {
-        /* Invalid parameter (wrong surface)! */
-        return;
-    }
-
-    if (DosRequestMutexSem (local_os2_surface->hmtx_use_private_fields, SEM_INDEFINITE_WAIT)
-        != NO_ERROR)
-    {
-        /* Could not get mutex! */
-        return;
-    }
-
-    local_os2_surface->hwnd_client_window = hwnd_client_window;
-
-    DosReleaseMutexSem (local_os2_surface->hmtx_use_private_fields);
-}
-
-/**
- * cairo_os2_surface_set_manual_window_refresh:
- * @surface: the cairo surface to set the refresh mode for
- * @manual_refresh: the switch for manual surface refresh
- *
- * This API can tell Cairo if it should show every change to this surface
- * immediately in the window or if it should be cached and will only be visible
- * once the user calls cairo_os2_surface_refresh_window() explicitly. If the
- * HWND was not set in the cairo surface, then the HPS will be used to blit the
- * graphics. Otherwise it will invalidate the given window region so the user
- * will get the WM_PAINT message to redraw that area of the window.
- *
- * So, if you're only interested in displaying the final result after several
- * drawing operations, you might get better performance if you put the surface
- * into manual refresh mode by passing a true value to this function. Then call
- * cairo_os2_surface_refresh() whenever desired.
- *
- * Since: 1.4
- **/
-void
-cairo_os2_surface_set_manual_window_refresh (cairo_surface_t *surface,
-                                             cairo_bool_t     manual_refresh)
-{
-    cairo_os2_surface_t *local_os2_surface;
-
-    local_os2_surface = (cairo_os2_surface_t *) surface;
-    if ((!local_os2_surface) ||
-        (local_os2_surface->base.backend != &cairo_os2_surface_backend))
-    {
-        /* Invalid parameter (wrong surface)! */
-        return;
-    }
-
-    local_os2_surface->blit_as_changes = !manual_refresh;
-}
-
-/**
- * cairo_os2_surface_get_manual_window_refresh:
- * @surface: the cairo surface to query the refresh mode from
- *
- * This space left intentionally blank.
- *
- * Return value: current refresh mode of the surface (true by default)
- *
- * Since: 1.4
- **/
-cairo_bool_t
-cairo_os2_surface_get_manual_window_refresh (cairo_surface_t *surface)
-{
-    cairo_os2_surface_t *local_os2_surface;
-
-    local_os2_surface = (cairo_os2_surface_t *) surface;
-    if ((!local_os2_surface) ||
-        (local_os2_surface->base.backend != &cairo_os2_surface_backend))
-    {
-        /* Invalid parameter (wrong surface)! */
-        return FALSE;
-    }
-
-    return !(local_os2_surface->blit_as_changes);
-}
-
-/**
- * cairo_os2_surface_get_hps:
- * @surface: the cairo surface to be querued
- * @hps: HPS currently associated with the surface (if any)
- *
- * This API retrieves the HPS associated with the surface.
- *
- * Return value: %CAIRO_STATUS_SUCCESS if the hps could be retrieved,
- * %CAIRO_STATUS_SURFACE_TYPE_MISMATCH if the surface is not an OS/2 surface,
- * %CAIRO_STATUS_NULL_POINTER if the hps argument is null
- *
- * Since: 1.10
- **/
-cairo_status_t
-cairo_os2_surface_get_hps (cairo_surface_t *surface,
-                           HPS             *hps)
-{
-    cairo_os2_surface_t *local_os2_surface;
-
-    local_os2_surface = (cairo_os2_surface_t *) surface;
-    if ((!local_os2_surface) ||
-        (local_os2_surface->base.backend != &cairo_os2_surface_backend))
-    {
-        /* Invalid parameter (wrong surface)! */
-        return _cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH);
-    }
-    if (!hps)
-    {
-        return _cairo_error (CAIRO_STATUS_NULL_POINTER);
-    }
-    *hps = local_os2_surface->hps_client_window;
-
-    return CAIRO_STATUS_SUCCESS;
-}
-
-/**
- * cairo_os2_surface_set_hps:
- * @surface: the cairo surface to associate with the HPS
- * @hps: new HPS to be associated with the surface (the HPS may be null)
- *
- * This API replaces the HPS associated with the surface with a new one.
- * The caller retains ownership of the HPS and must dispose of it after
- * the surface has been destroyed or it has been replaced by another
- * call to this function.
- *
- * Return value: %CAIRO_STATUS_SUCCESS if the hps could be replaced,
- * %CAIRO_STATUS_SURFACE_TYPE_MISMATCH if the surface is not an OS/2 surface,
- *
- * Since: 1.10
- **/
-cairo_status_t
-cairo_os2_surface_set_hps (cairo_surface_t *surface,
-                           HPS              hps)
-{
-    cairo_os2_surface_t *local_os2_surface;
-
-    local_os2_surface = (cairo_os2_surface_t *) surface;
-    if ((!local_os2_surface) ||
-        (local_os2_surface->base.backend != &cairo_os2_surface_backend))
-    {
-        /* Invalid parameter (wrong surface)! */
-        return _cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH);
-    }
-    local_os2_surface->hps_client_window = hps;
-
-    return CAIRO_STATUS_SUCCESS;
-}
-
-static cairo_status_t
-_cairo_os2_surface_mark_dirty_rectangle (void *surface,
-                                         int   x,
-                                         int   y,
-                                         int   width,
-                                         int   height)
-{
-    cairo_os2_surface_t *local_os2_surface;
-    RECTL rclToBlit;
-
-    local_os2_surface = (cairo_os2_surface_t *) surface;
-    if ((!local_os2_surface) ||
-        (local_os2_surface->base.backend != &cairo_os2_surface_backend))
-    {
-        /* Invalid parameter (wrong surface)! */
-        return _cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH);
-    }
-
-    /* Get mutex, we'll work with the pixel array! */
-    if (DosRequestMutexSem (local_os2_surface->hmtx_use_private_fields, SEM_INDEFINITE_WAIT)
-        != NO_ERROR)
-    {
-        /* Could not get mutex! */
-        return CAIRO_STATUS_NO_MEMORY;
-    }
-
-    /* Check for defaults */
-    if (width < 0)
-        width = local_os2_surface->bitmap_info.cx;
-    if (height < 0)
-        height = local_os2_surface->bitmap_info.cy;
-
-    if (local_os2_surface->hwnd_client_window) {
-        /* We know the HWND, so let's invalidate the window region,
-         * so the application will redraw itself, using the
-         * cairo_os2_surface_refresh_window () API from its own PM thread.
-         * From that function we'll note that it's not a redraw but a
-         * dirty-rectangle deal stuff, so we'll handle the things from
-         * there.
-         *
-         * This is the safe method, which should be preferred every time.
-         */
-        rclToBlit.xLeft = x;
-        rclToBlit.xRight = x + width; /* Noninclusive */
-        rclToBlit.yTop = local_os2_surface->bitmap_info.cy - (y);
-        rclToBlit.yBottom = local_os2_surface->bitmap_info.cy - (y + height); /* Noninclusive */
-
-#if 0
-        if (local_os2_surface->dirty_area_present) {
-            /* Yikes, there is already a dirty area which should be
-             * cleaned up, but we'll overwrite it. Sorry.
-             * TODO: Something clever should be done here.
-             */
-        }
-#endif
-
-        /* Set up dirty area reminder stuff */
-        memcpy (&(local_os2_surface->rcl_dirty_area), &rclToBlit, sizeof (RECTL));
-        local_os2_surface->dirty_area_present = TRUE;
-
-        /* Invalidate window area */
-        WinInvalidateRect (local_os2_surface->hwnd_client_window,
-                           &rclToBlit,
-                           FALSE);
-    } else {
-        /* We don't know the HWND, so try to blit the pixels from here!
-         * Please note that it can be problematic if this is not the PM thread!
-         *
-         * It can cause internal PM stuffs to be scewed up, for some reason.
-         * Please always tell the HWND to the surface using the
-         * cairo_os2_surface_set_hwnd () API, and call cairo_os2_surface_refresh_window ()
-         * from your WM_PAINT, if it's possible!
-         */
-
-        rclToBlit.xLeft = x;
-        rclToBlit.xRight = x + width; /* Noninclusive */
-        rclToBlit.yBottom = y;
-        rclToBlit.yTop = y + height; /* Noninclusive */
-        /* Now get the pixels from the screen! */
-        _cairo_os2_surface_get_pixels_from_screen (local_os2_surface,
-                                                   local_os2_surface->hps_client_window,
-                                                   &rclToBlit);
-    }
-
-    DosReleaseMutexSem (local_os2_surface->hmtx_use_private_fields);
-
-    return CAIRO_STATUS_SUCCESS;
-}
-
-static const cairo_surface_backend_t cairo_os2_surface_backend = {
-    CAIRO_SURFACE_TYPE_OS2,
-    _cairo_os2_surface_finish,
-    _cairo_default_context_create,
-
-    NULL, /* create_similar */
-    NULL, /* create_similar_image */
-    _cairo_os2_surface_map_to_image,
-    _cairo_os2_surface_unmap_image,
-
-    _cairo_surface_default_source,
-    _cairo_os2_surface_acquire_source_image,
-    _cairo_os2_surface_release_source_image,
-    NULL, /* snapshot */
-
-    _cairo_os2_surface_get_extents,
-    NULL, /* get_font_options */
-
-    NULL, /* flush */
-    _cairo_os2_surface_mark_dirty_rectangle,
-
-    _cairo_surface_fallback_paint,
-    _cairo_surface_fallback_mask,
-    _cairo_surface_fallback_fill,
-    _cairo_surface_fallback_stroke,
-    NULL, /* fill/stroke */
-    _cairo_surface_fallback_glyphs,
-};
+

cairo/trunk/src/cairo-os2.h ¶

@@ -34 +34 @@
  * Contributor(s):
  *     Peter Weilbacher <mozilla@Weilbacher.org>
- *     Rich Walsh <dragtext@e-vertise.com>
+ *     Rich Walsh <rich@e-vertise.com>
  */
 
@@ -40 +40 @@
 #define _CAIRO_OS2_H_
 
-#define INCL_DOS
-#define INCL_DOSSEMAPHORES
-#define INCL_DOSERRORS
-#define INCL_WIN
-#define INCL_GPI
+#include <os2.h>
 
 #include "cairo.h"
-
-#include <os2.h>
 
 CAIRO_BEGIN_DECLS
@@ -63 +57 @@
 
 cairo_public cairo_surface_t *
-cairo_os2_surface_create (HPS hps_client_window,
-                          int width,
-                          int height);
+cairo_os2_surface_create (cairo_format_t  format,
+                          int             width,
+                          int             height);
 
 cairo_public cairo_surface_t *
-cairo_os2_surface_create_for_window (HWND hwnd_client_window,
-                                     int  width,
-                                     int  height);
+cairo_os2_surface_create_for_window (HWND  hwnd,
+                                     int   width,
+                                     int   height);
 
-cairo_public void
-cairo_os2_surface_set_hwnd (cairo_surface_t *surface,
-                            HWND             hwnd_client_window);
+cairo_public cairo_surface_t *
+cairo_os2_surface_create_null_surface (HPS  hps,
+                                       int  width,
+                                       int  height);
 
-cairo_public int
-cairo_os2_surface_set_size (cairo_surface_t *surface,
-                            int              new_width,
-                            int              new_height,
-                            int              timeout);
+cairo_public cairo_status_t
+cairo_os2_surface_paint_window (cairo_surface_t *surface,
+                                HPS              hps,
+                                RECTL           *rect,
+                                int              count);
 
-cairo_public void
-cairo_os2_surface_refresh_window (cairo_surface_t *surface,
-                                  HPS              hps_begin_paint,
-                                  PRECTL           prcl_begin_paint_rect);
-
-cairo_public void
-cairo_os2_surface_set_manual_window_refresh (cairo_surface_t *surface,
-                                             cairo_bool_t     manual_refresh);
-
-cairo_public cairo_bool_t
-cairo_os2_surface_get_manual_window_refresh (cairo_surface_t *surface);
+cairo_public cairo_status_t
+cairo_os2_surface_paint_bitmap (cairo_surface_t *surface,
+                                HPS              hps,
+                                RECTL           *src,
+                                RECTL           *dst,
+                                int              count,
+                                BOOL             use24bpp);
 
 cairo_public cairo_status_t
@@ -102 +93 @@
                            HPS              hps);
 
+cairo_public cairo_status_t
+cairo_os2_surface_set_hwnd (cairo_surface_t *surface,
+                            HWND             hwnd);
+
+cairo_public cairo_status_t
+cairo_os2_surface_set_size (cairo_surface_t *surface,
+                            int              width,
+                            int              height,
+                            int              copy);
+
+cairo_public cairo_bool_t
+cairo_os2_surface_enable_dive (cairo_bool_t enable,
+                               cairo_bool_t hide_pointer);
+
 #else  /* CAIRO_HAS_OS2_SURFACE */
 # error Cairo was not compiled with support for the OS/2 backend

cairo/trunk/test/error-setters.c ¶

@@ -67 +67 @@
     cairo_os2_surface_set_hwnd (surface, 0);
     cairo_os2_surface_set_size (surface, 0, 0, 0);
-    cairo_os2_surface_set_manual_window_refresh (surface, FALSE);
 #endif