TQt4 port koffice

This should enable compilation under both Qt3 and Qt4; fixes for any missed components will be forthcoming


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/koffice@1238284 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 15 insertions, 15 deletions

diff --git a/karbon/render/xrgbrender/gdk-pixbuf-xlib-render.c b/karbon/render/xrgbrender/gdk-pixbuf-xlib-render.c
index f2439138..f8f890e3 100644
--- a/karbon/render/xrgbrender/gdk-pixbuf-xlib-render.c
+++ b/karbon/render/xrgbrender/gdk-pixbuf-xlib-render.c
@@ -31,7 +31,7 @@
 **
  * gdk_pixbuf_xlib_render_threshold_alpha:
  * @pixbuf: A pixbuf.
- * @bitmap: Bitmap where the bilevel mask will be painted to.
+ * @bitmap: Bitmap where the bilevel tqmask will be painted to.
  * @src_x: Source X coordinate.
  * @src_y: source Y coordinate.
  * @dest_x: Destination X coordinate.
@@ -42,7 +42,7 @@
  * other values will be painted as one.
  *
  * Takes the opacity values in a rectangular portion of a pixbuf and thresholds
- * them to produce a bi-level alpha mask that can be used as a clipping mask for
+ * them to produce a bi-level alpha tqmask that can be used as a clipping tqmask for
  * a drawable.
  *
 void
@@ -177,7 +177,7 @@ remove_alpha (GdkPixbuf *pixbuf, int x, int y, int width, int height, int *rowst
  * specified GC.  This is done using XlibRGB, so the specified drawable must
  * have the XlibRGB visual and colormap.  Note that this function will ignore
  * the opacity information for images with an alpha channel; the GC must already
- * have the clipping mask set if you want transparent regions to show through.
+ * have the clipping tqmask set if you want transparent regions to show through.
  *
  * For an explanation of dither offsets, see the XlibRGB documentation.  In
  * brief, the dither offset is important when re-rendering partial regions of an
@@ -255,7 +255,7 @@ gdk_pixbuf_xlib_render_to_drawable (GdkPixbuf *pixbuf,
  *
  * When used with #GDK_PIXBUF_ALPHA_BILEVEL, this function has to create a bitmap
  * out of the thresholded alpha channel of the image and, it has to set this
- * bitmap as the clipping mask for the GC used for drawing.  This can be a
+ * bitmap as the clipping tqmask for the GC used for drawing.  This can be a
  * significant performance penalty depending on the size and the complexity of
  * the alpha channel of the image.  If performance is crucial, consider handling
  * the alpha channel yourself (possibly by caching it in your application) and
@@ -320,23 +320,23 @@ gdk_pixbuf_xlib_render_to_drawable_alpha (GdkPixbuf *pixbuf, Drawable drawable,
 
  * @pixbuf: A pixbuf.
  * @pixmap_return: Return value for the created pixmap.
- * @mask_return: Return value for the created mask.
+ * @tqmask_return: Return value for the created tqmask.
  * @alpha_threshold: Threshold value for opacity values.
  *
- * Creates a pixmap and a mask bitmap which are returned in the @pixmap_return
- * and @mask_return arguments, respectively, and renders a pixbuf and its
- * corresponding tresholded alpha mask to them.  This is merely a convenience
+ * Creates a pixmap and a tqmask bitmap which are returned in the @pixmap_return
+ * and @tqmask_return arguments, respectively, and renders a pixbuf and its
+ * corresponding tresholded alpha tqmask to them.  This is merely a convenience
  * function; applications that need to render pixbufs with dither offsets or to
  * given drawables should use gdk_pixbuf_xlib_render_to_drawable_alpha() or
  * gdk_pixbuf_xlib_render_to_drawable(), and
  * gdk_pixbuf_xlib_render_threshold_alpha().
  *
- * If the pixbuf does not have an alpha channel, then *@mask_return will be set
+ * If the pixbuf does not have an alpha channel, then *@tqmask_return will be set
  * to None.
 void
-gdk_pixbuf_xlib_render_pixmap_and_mask (GdkPixbuf *pixbuf,
+gdk_pixbuf_xlib_render_pixmap_and_tqmask (GdkPixbuf *pixbuf,
 					Pixmap *pixmap_return,
-					Pixmap *mask_return,
+					Pixmap *tqmask_return,
 					int alpha_threshold)
 {
         g_return_if_fail (pixbuf != NULL);
@@ -361,20 +361,20 @@ gdk_pixbuf_xlib_render_pixmap_and_mask (GdkPixbuf *pixbuf,
 		XFreeGC (gdk_pixbuf_dpy, gc);
 	}
 
-	if (mask_return) {
+	if (tqmask_return) {
 		if (pixbuf->has_alpha) {
-		    *mask_return = XCreatePixmap (gdk_pixbuf_dpy,
+		    *tqmask_return = XCreatePixmap (gdk_pixbuf_dpy,
 						  RootWindow (gdk_pixbuf_dpy,
 							      gdk_pixbuf_screen),
 						  pixbuf->width,
 						  pixbuf->height, 1);
 		    gdk_pixbuf_xlib_render_threshold_alpha (pixbuf,
-							    *mask_return,
+							    *tqmask_return,
 							    0, 0, 0, 0,
 							    pixbuf->width,
 							    pixbuf->height,
 							    alpha_threshold);
 		} else
-			*mask_return = 0;
+			*tqmask_return = 0;
 	}
 }*/