callisto-debian/gtk3
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove deprecated code from GdkImage

Browse Source
This commit is contained in:
Javier Jardón
2009-10-09 18:13:00 +02:00
committed by Javier Jardón
parent 7894951cee
commit 906a510007
11 changed files with 22 additions and 313 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
docs/reference/gdk-pixbuf/tmpl/gdk-pixbuf-unused.sgml
View File

@ -8,12 +8,6 @@
</para> </para>
<!-- ##### SECTION ./tmpl/from-drawables.sgml:See_Also ##### -->
<para>
gdk_image_get().
</para>
<!-- ##### SECTION ./tmpl/from-drawables.sgml:Short_Description ##### --> <!-- ##### SECTION ./tmpl/from-drawables.sgml:Short_Description ##### -->
Getting parts of a drawable's image data into a pixbuf. Getting parts of a drawable's image data into a pixbuf.

5
docs/reference/gdk/gdk-sections.txt
View File

@ -281,11 +281,6 @@ GdkPixmapObjectClass
GdkImage GdkImage
gdk_image_new gdk_image_new
GdkImageType GdkImageType
gdk_image_new_bitmap
gdk_image_get
gdk_image_ref
gdk_image_unref
gdk_image_destroy
gdk_image_get_colormap gdk_image_get_colormap
gdk_image_set_colormap gdk_image_set_colormap

52
docs/reference/gdk/tmpl/images.sgml
View File

@ -12,7 +12,6 @@ It has now been superceded to a large extent by the much more flexible
</para> </para>
<para> <para>
To create an empty #GdkImage use gdk_image_new(). To create an empty #GdkImage use gdk_image_new().
To create a #GdkImage from bitmap data use gdk_image_new_bitmap().
To create an image from part of a #GdkWindow use gdk_drawable_get_image(). To create an image from part of a #GdkWindow use gdk_drawable_get_image().
</para> </para>
<para> <para>
@ -25,7 +24,7 @@ the different formats that may be used.
To draw a #GdkImage in a #GdkWindow or #GdkPixmap use gdk_draw_image(). To draw a #GdkImage in a #GdkWindow or #GdkPixmap use gdk_draw_image().
</para> </para>
<para> <para>
To destroy a #GdkImage use gdk_image_destroy(). To destroy a #GdkImage use g_object_unref().
</para> </para>
<!-- ##### SECTION See_Also ##### --> <!-- ##### SECTION See_Also ##### -->
@ -105,55 +104,6 @@ is supported by the server.
@GDK_IMAGE_FASTEST: Specifies that %GDK_IMAGE_SHARED should be tried first, @GDK_IMAGE_FASTEST: Specifies that %GDK_IMAGE_SHARED should be tried first,
and if that fails then %GDK_IMAGE_NORMAL will be used. and if that fails then %GDK_IMAGE_NORMAL will be used.
<!-- ##### FUNCTION gdk_image_new_bitmap ##### -->
<para>
</para>
@visual:
@data:
@width:
@height:
@Returns:
<!-- ##### FUNCTION gdk_image_get ##### -->
<para>
</para>
@drawable:
@x:
@y:
@width:
@height:
@Returns:
<!-- ##### FUNCTION gdk_image_ref ##### -->
<para>
</para>
@image:
@Returns:
<!-- ##### FUNCTION gdk_image_unref ##### -->
<para>
</para>
@image:
<!-- ##### MACRO gdk_image_destroy ##### -->
<para>
Destroys a #GdkImage, freeing any resources allocated for it.
</para>
<!-- # Unused Parameters # -->
@image: a #GdkImage.
<!-- ##### FUNCTION gdk_image_get_colormap ##### --> <!-- ##### FUNCTION gdk_image_get_colormap ##### -->
<para> <para>

36
gdk/directfb/gdkimage-directfb.c
View File

@ -131,40 +131,6 @@ _gdk_image_exit (void)
} }
} }
GdkImage *
gdk_image_new_bitmap (GdkVisual *visual,
gpointer data,
gint w,
gint h)
{
GdkImage *image;
GdkImageDirectFB *private;
image = g_object_new (gdk_image_get_type (), NULL);
private = image->windowing_data;
image->type = GDK_IMAGE_SHARED;
image->visual = visual;
image->width = w;
image->height = h;
image->depth = 1;
GDK_NOTE (MISC, g_print ("gdk_image_new_bitmap: %dx%d\n", w, h));
g_message ("not fully implemented %s", G_STRFUNC);
image->bpl = (w + 7) / 8;
image->mem = g_malloc (image->bpl * h);
#if G_BYTE_ORDER == G_BIG_ENDIAN
image->byte_order = GDK_MSB_FIRST;
#else
image->byte_order = GDK_LSB_FIRST;
#endif
image->bpp = 1;
return image;
}
void void
_gdk_windowing_image_init (void) _gdk_windowing_image_init (void)
{ {
@ -229,7 +195,7 @@ _gdk_image_new_for_depth (GdkScreen *screen,
if (ret) if (ret)
{ {
DirectFBError( "IDirectFBSurface::Lock() for writing failed!\n", ret ); DirectFBError( "IDirectFBSurface::Lock() for writing failed!\n", ret );
gdk_image_unref( image ); g_object_unref( image );
return NULL; return NULL;
} }

8
gdk/gdk.symbols
View File

@ -794,11 +794,6 @@ gdk_window_configure_finished
#if IN_HEADER(__GDK_IMAGE_H__) #if IN_HEADER(__GDK_IMAGE_H__)
#if IN_FILE(__GDK_IMAGE_C__) #if IN_FILE(__GDK_IMAGE_C__)
#ifndef GDK_DISABLE_DEPRECATED
gdk_image_ref
gdk_image_unref
gdk_image_get
#endif
gdk_image_set_colormap gdk_image_set_colormap
gdk_image_get_colormap gdk_image_get_colormap
gdk_image_new gdk_image_new
@ -807,9 +802,6 @@ gdk_image_new
#if IN_HEADER(__GDK_IMAGE_H__) #if IN_HEADER(__GDK_IMAGE_H__)
#if IN_FILE(__GDK_IMAGE_X11_C__) #if IN_FILE(__GDK_IMAGE_X11_C__)
#ifdef GDK_ENABLE_BROKEN
gdk_image_new_bitmap
#endif
gdk_image_get_pixel gdk_image_get_pixel
gdk_image_put_pixel gdk_image_put_pixel
gdk_image_get_type G_GNUC_CONST gdk_image_get_type G_GNUC_CONST

65
gdk/gdkimage.c
View File

@ -34,71 +34,6 @@
#include "gdkinternals.h" /* For scratch_image code */ #include "gdkinternals.h" /* For scratch_image code */
#include "gdkalias.h" #include "gdkalias.h"
/**
* gdk_image_ref:
* @image: a #GdkImage
*
* Deprecated function; use g_object_ref() instead.
*
* Return value: the image
*
* Deprecated: 2.0: Use g_object_ref() instead.
**/
GdkImage *
gdk_image_ref (GdkImage *image)
{
g_return_val_if_fail (GDK_IS_IMAGE (image), NULL);
return g_object_ref (image);
}
/**
* gdk_image_unref:
* @image: a #GdkImage
*
* Deprecated function; use g_object_unref() instead.
*
* Deprecated: 2.0: Use g_object_unref() instead.
**/
void
gdk_image_unref (GdkImage *image)
{
g_return_if_fail (GDK_IS_IMAGE (image));
g_object_unref (image);
}
/**
* gdk_image_get:
* @drawable: a #GdkDrawable
* @x: x coordinate in @window
* @y: y coordinate in @window
* @width: width of area in @window
* @height: height of area in @window
*
* This is a deprecated wrapper for gdk_drawable_get_image();
* gdk_drawable_get_image() should be used instead. Or even better: in
* most cases gdk_pixbuf_get_from_drawable() is the most convenient
* choice.
*
* Return value: a new #GdkImage or %NULL
**/
GdkImage*
gdk_image_get (GdkWindow *drawable,
gint x,
gint y,
gint width,
gint height)
{
g_return_val_if_fail (GDK_IS_DRAWABLE (drawable), NULL);
g_return_val_if_fail (x >= 0, NULL);
g_return_val_if_fail (y >= 0, NULL);
g_return_val_if_fail (width >= 0, NULL);
g_return_val_if_fail (height >= 0, NULL);
return gdk_drawable_get_image (drawable, x, y, width, height);
}
/** /**
* gdk_image_set_colormap: * gdk_image_set_colormap:
* @image: a #GdkImage * @image: a #GdkImage

22
gdk/gdkimage.h
View File

@ -97,17 +97,6 @@ GdkImage* gdk_image_new (GdkImageType type,
gint width, gint width,
gint height); gint height);
#ifndef GDK_DISABLE_DEPRECATED
GdkImage* gdk_image_get (GdkDrawable *drawable,
gint x,
gint y,
gint width,
gint height);
GdkImage * gdk_image_ref (GdkImage *image);
void gdk_image_unref (GdkImage *image);
#endif
void gdk_image_put_pixel (GdkImage *image, void gdk_image_put_pixel (GdkImage *image,
gint x, gint x,
gint y, gint y,
@ -121,17 +110,6 @@ void gdk_image_set_colormap (GdkImage *image,
GdkColormap* gdk_image_get_colormap (GdkImage *image); GdkColormap* gdk_image_get_colormap (GdkImage *image);
#ifdef GDK_ENABLE_BROKEN
GdkImage* gdk_image_new_bitmap (GdkVisual *visual,
gpointer data,
gint width,
gint height);
#endif /* GDK_ENABLE_BROKEN */
#ifndef GDK_DISABLE_DEPRECATED
#define gdk_image_destroy g_object_unref
#endif /* GDK_DISABLE_DEPRECATED */
G_END_DECLS G_END_DECLS
#endif /* __GDK_IMAGE_H__ */ #endif /* __GDK_IMAGE_H__ */

10
gdk/quartz/gdkimage-quartz.c
View File

@ -224,16 +224,6 @@ gdk_image_get_type (void)
return object_type; return object_type;
} }
GdkImage *
gdk_image_new_bitmap (GdkVisual *visual, gpointer data, gint width, gint height)
{
/* We don't implement this function because it's broken, deprecated and
* tricky to implement. */
g_warning ("This function is unimplemented");
return NULL;
}
GdkImage* GdkImage*
_gdk_image_new_for_depth (GdkScreen *screen, _gdk_image_new_for_depth (GdkScreen *screen,
GdkImageType type, GdkImageType type,

40
gdk/testgdk.c
View File

@ -364,12 +364,12 @@ test_pixmaps (gint depth)
gdk_window_get_size (pixmap, &w, &h); gdk_window_get_size (pixmap, &w, &h);
QTESTF (w == width, (" w:%d", w)); QTESTF (w == width, (" w:%d", w));
QTESTF (h == height, (" h:%d", h)); QTESTF (h == height, (" h:%d", h));
image = gdk_image_get (pixmap, 0, 0, w, h); image = gdk_drawable_get_image (pixmap, 0, 0, w, h);
QTEST (image != NULL); QTEST (image != NULL);
QTEST (image->width == width); QTEST (image->width == width);
QTEST (image->height == height); QTEST (image->height == height);
QTEST (image->depth == depth); QTEST (image->depth == depth);
gdk_image_destroy (image); g_object_unref (image);
g_object_unref (pixmap); g_object_unref (pixmap);
} }
TEST (retval); TEST (retval);
@ -405,7 +405,7 @@ test_images (void)
QTEST (image->depth == system_visual->depth); QTEST (image->depth == system_visual->depth);
QTEST (image->bpp >= (image->depth-1)/8 + 1); QTEST (image->bpp >= (image->depth-1)/8 + 1);
QTEST (image->mem != NULL); QTEST (image->mem != NULL);
gdk_image_destroy (image); g_object_unref (image);
} }
} }
TEST (retval); TEST (retval);
@ -512,14 +512,14 @@ test_one_point_on_drawable (GdkDrawable *drawable,
gdk_gc_get_values (gc, &gcvalues); gdk_gc_get_values (gc, &gcvalues);
image = gdk_image_get (drawable, x+-1, y+-1, 3, 3); image = gdk_drawable_get_image (drawable, x+-1, y+-1, 3, 3);
QTEST (image != NULL); QTEST (image != NULL);
for (xoff = -1; xoff <= 1; xoff++) for (xoff = -1; xoff <= 1; xoff++)
for (yoff = -1; yoff <= 1; yoff++) for (yoff = -1; yoff <= 1; yoff++)
{ {
oldpixels[xoff+1][yoff+1] = gdk_image_get_pixel (image, xoff+1, yoff+1); oldpixels[xoff+1][yoff+1] = gdk_image_get_pixel (image, xoff+1, yoff+1);
} }
gdk_image_destroy (image); g_object_unref (image);
if (depth == 32) if (depth == 32)
mask = 0xFFFFFFFF; mask = 0xFFFFFFFF;
@ -528,7 +528,7 @@ test_one_point_on_drawable (GdkDrawable *drawable,
gdk_draw_point (drawable, gc, x, y); gdk_draw_point (drawable, gc, x, y);
image = gdk_image_get (drawable, x-1, y-1, 3, 3); image = gdk_drawable_get_image (drawable, x-1, y-1, 3, 3);
QTEST (image != NULL); QTEST (image != NULL);
for (xoff = -1; xoff <= 1; xoff++) for (xoff = -1; xoff <= 1; xoff++)
for (yoff = -1; yoff <= 1; yoff++) for (yoff = -1; yoff <= 1; yoff++)
@ -540,7 +540,7 @@ test_one_point_on_drawable (GdkDrawable *drawable,
else else
QTEST (newpixel == oldpixels[xoff+1][yoff+1]); QTEST (newpixel == oldpixels[xoff+1][yoff+1]);
} }
gdk_image_destroy (image); g_object_unref (image);
} }
@ -601,7 +601,7 @@ test_one_line_on_drawable (GdkDrawable *drawable,
w_up = w_left = line_width/2; w_up = w_left = line_width/2;
w_down = w_right = (line_width & 1) ? line_width/2 : line_width/2-1; w_down = w_right = (line_width & 1) ? line_width/2 : line_width/2-1;
gdk_window_get_size (drawable, &w, &h); gdk_window_get_size (drawable, &w, &h);
oldimage = gdk_image_get (drawable, 0, 0, w, h); oldimage = gdk_drawable_get_image (drawable, 0, 0, w, h);
if (depth == 32) if (depth == 32)
mask = 0xFFFFFFFF; mask = 0xFFFFFFFF;
@ -616,7 +616,7 @@ test_one_line_on_drawable (GdkDrawable *drawable,
const gint y2 = y1; const gint y2 = y1;
gdk_draw_line (drawable, gc, x1, y1, x2, y2); gdk_draw_line (drawable, gc, x1, y1, x2, y2);
newimage = gdk_image_get (drawable, 0, 0, w, h); newimage = gdk_drawable_get_image (drawable, 0, 0, w, h);
for (x = x1-1; x <= x2+1; x++) for (x = x1-1; x <= x2+1; x++)
for (y = y1-w_up-1; y <= y1+w_down+1; y++) for (y = y1-w_up-1; y <= y1+w_down+1; y++)
{ {
@ -637,7 +637,7 @@ test_one_line_on_drawable (GdkDrawable *drawable,
const gint y2 = 13; const gint y2 = 13;
gdk_draw_line (drawable, gc, x1, y1, x2, y2); gdk_draw_line (drawable, gc, x1, y1, x2, y2);
newimage = gdk_image_get (drawable, 0, 0, w, h); newimage = gdk_drawable_get_image (drawable, 0, 0, w, h);
for (x = x1-w_left-1; x <= x1+w_right+1; x++) for (x = x1-w_left-1; x <= x1+w_right+1; x++)
for (y = y1-1; y <= y2+1; y++) for (y = y1-1; y <= y2+1; y++)
{ {
@ -651,8 +651,8 @@ test_one_line_on_drawable (GdkDrawable *drawable,
} }
} }
gdk_image_destroy (oldimage); g_object_unref (oldimage);
gdk_image_destroy (newimage); g_object_unref (newimage);
} }
/* Test drawing lines. /* Test drawing lines.
@ -715,7 +715,7 @@ test_one_rectangle_on_drawable (GdkDrawable *drawable,
} }
gdk_window_get_size (drawable, &w, &h); gdk_window_get_size (drawable, &w, &h);
oldimage = gdk_image_get (drawable, 0, 0, w, h); oldimage = gdk_drawable_get_image (drawable, 0, 0, w, h);
if (depth == 32) if (depth == 32)
mask = 0xFFFFFFFF; mask = 0xFFFFFFFF;
@ -723,7 +723,7 @@ test_one_rectangle_on_drawable (GdkDrawable *drawable,
mask = (1 << depth) - 1; mask = (1 << depth) - 1;
gdk_draw_rectangle (drawable, gc, filled, x0, y0, width, height); gdk_draw_rectangle (drawable, gc, filled, x0, y0, width, height);
newimage = gdk_image_get (drawable, 0, 0, w, h); newimage = gdk_drawable_get_image (drawable, 0, 0, w, h);
for (x = x0 - 1; x <= x0 + width + 1; x++) for (x = x0 - 1; x <= x0 + width + 1; x++)
for (y = y0 - 1; y < y0 + height + 1; y++) for (y = y0 - 1; y < y0 + height + 1; y++)
@ -757,8 +757,8 @@ test_one_rectangle_on_drawable (GdkDrawable *drawable,
} }
} }
gdk_image_destroy (oldimage); g_object_unref (oldimage);
gdk_image_destroy (newimage); g_object_unref (newimage);
} }
/* Test drawing rectangles. /* Test drawing rectangles.
@ -821,7 +821,7 @@ test_some_arcs_on_drawable (GdkDrawable *drawable,
} }
gdk_window_get_size (drawable, &w, &h); gdk_window_get_size (drawable, &w, &h);
oldimage = gdk_image_get (drawable, 0, 0, w, h); oldimage = gdk_drawable_get_image (drawable, 0, 0, w, h);
if (depth == 32) if (depth == 32)
mask = 0xFFFFFFFF; mask = 0xFFFFFFFF;
@ -829,7 +829,7 @@ test_some_arcs_on_drawable (GdkDrawable *drawable,
mask = (1 << depth) - 1; mask = (1 << depth) - 1;
/* XXX */ /* XXX */
newimage = gdk_image_get (drawable, 0, 0, w, h); newimage = gdk_drawable_get_image (drawable, 0, 0, w, h);
for (x = x0 - 1; x <= x0 + width + 1; x++) for (x = x0 - 1; x <= x0 + width + 1; x++)
for (y = y0 - 1; y < y0 + height + 1; y++) for (y = y0 - 1; y < y0 + height + 1; y++)
@ -847,8 +847,8 @@ test_some_arcs_on_drawable (GdkDrawable *drawable,
} }
} }
gdk_image_destroy (oldimage); g_object_unref (oldimage);
gdk_image_destroy (newimage); g_object_unref (newimage);
} }
/* Test drawing arcs. Results don't have to be exactly as on X11, /* Test drawing arcs. Results don't have to be exactly as on X11,

35
gdk/win32/gdkimage-win32.c
View File

@ -163,41 +163,6 @@ _gdk_win32_new_image (GdkVisual *visual,
return image; return image;
} }
GdkImage *
gdk_image_new_bitmap (GdkVisual *visual,
gpointer data,
gint w,
gint h)
{
GdkPixmap *pixmap;
GdkImage *image;
guchar *bits;
gint data_bpl = (w-1)/8 + 1;
gint i;
pixmap = gdk_pixmap_new (NULL, w, h, 1);
if (pixmap == NULL)
return NULL;
GDK_NOTE (IMAGE, g_print ("gdk_image_new_bitmap: %dx%d=%p\n",
w, h, GDK_PIXMAP_HBITMAP (pixmap)));
bits = GDK_PIXMAP_IMPL_WIN32 (GDK_PIXMAP_OBJECT (pixmap)->impl)->bits;
image = _gdk_win32_new_image (visual, w, h, 1, bits);
image->windowing_data = pixmap;
if (data_bpl != image->bpl)
{
for (i = 0; i < h; i++)
memmove ((guchar *) image->mem + i*image->bpl, ((guchar *) data) + i*data_bpl, data_bpl);
}
else
memmove (image->mem, data, data_bpl*h);
return image;
}
void void
_gdk_windowing_image_init (void) _gdk_windowing_image_init (void)
{ {

56
gdk/x11/gdkimage-x11.c
View File

@ -116,62 +116,6 @@ _gdk_image_exit (void)
} }
} }
/**
* gdk_image_new_bitmap:
* @visual: the #GdkVisual to use for the image.
* @data: the pixel data.
* @width: the width of the image in pixels.
* @height: the height of the image in pixels.
*
* Creates a new #GdkImage with a depth of 1 from the given data.
* <warning><para>THIS FUNCTION IS INCREDIBLY BROKEN. The passed-in data must
* be allocated by malloc() (NOT g_malloc()) and will be freed when the
* image is freed.</para></warning>
*
* Return value: a new #GdkImage.
**/
GdkImage *
gdk_image_new_bitmap (GdkVisual *visual,
gpointer data,
gint width,
gint height)
{
Visual *xvisual;
GdkImage *image;
GdkDisplay *display;
GdkImagePrivateX11 *private;
image = g_object_new (gdk_image_get_type (), NULL);
private = PRIVATE_DATA (image);
private->screen = gdk_visual_get_screen (visual);
display = GDK_SCREEN_DISPLAY (private->screen);
image->type = GDK_IMAGE_NORMAL;
image->visual = visual;
image->width = width;
image->height = height;
image->depth = 1;
image->bits_per_pixel = 1;
if (display->closed)
private->ximage = NULL;
else
{
xvisual = ((GdkVisualPrivate*) visual)->xvisual;
private->ximage = XCreateImage (GDK_SCREEN_XDISPLAY (private->screen),
xvisual, 1, XYBitmap,
0, NULL, width, height, 8, 0);
private->ximage->data = data;
private->ximage->bitmap_bit_order = MSBFirst;
private->ximage->byte_order = MSBFirst;
}
image->byte_order = MSBFirst;
image->mem = private->ximage->data;
image->bpl = private->ximage->bytes_per_line;
image->bpp = 1;
return image;
}
void void
_gdk_windowing_image_init (GdkDisplay *display) _gdk_windowing_image_init (GdkDisplay *display)
{ {