← Back to branch summary

~canonical-dx-team/ubuntu/maverick/gtk+2.0/menuproxy

« back to all changes in this revision

Viewing changes to gdk/x11/gdkpixmap-x11.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastien Bacher
  • Date: 2007-05-04 12:24:25 UTC
  • mfrom: (1.1.21 upstream)
  • Revision ID: james.westby@ubuntu.com-20070504122425-0m8midgzrp40y8w2
Tags: 2.10.12-1ubuntu1
* Sync with Debian
* New upstream version:
  Fixed bugs:
  - 379414 file chooser warnings when changing path in the entry
  - 418585 GtkFileChooserDefault sizing code is not DPI independent
  - 419568 Crash in search if start with special letter
  - 435062 build dies with icon cache validation
  - 379399 Segfault to call gtk_print_operation_run twice.
  - 387889 cups backend has problems when there are too many printers
  - 418531 invalid read to gtkicontheme.c gtk_icon_theme_lookup_icon...
  - 423916 crash in color scheme code
  - 424042 Segmentation fault while quickly pressing Alt+arrows
  - 415260 Protect against negative indices when setting values in G...
  - 419171 XGetVisualInfo() may not set nxvisuals
  - 128852 Gdk cursors don't look good on win32
  - 344657 Ctrl-H doesn't toggle "Show Hidden Files" setting
  - 345345 PrintOperation::paginate is not emitted for class handler
  - 347567 GtkPrintOperation::end-print is not emitted if it's cance...
  - 369112 gtk_ui_manager_add_ui should accept unnamed separator
  - 392015 Selected menu item invisible on Windows Vista
  - 399253 MS-Windows Theme Bottom Tab placement rendering glitches
  - 399425 gtk_input_dialog_fill_axes() adds child to gtkscrolledwin...
  - 403251 [patch] little memory leak in GtkPrintJob
  - 403267 [patch] memory leak in GtkPageSetupUnixDialog
  - 403470 MS-Windows Theme tab placement other than on top leaks a ...
  - 404506 Windows system fonts that have multi-byte font names cann...
  - 405089 Incorrect window placement for GtkEventBox private window
  - 405515 Minor leak in gtkfilesystemmodel.c
  - 405539 gdk_pixbuf_save() for PNG saver can return FALSE without ...
  - 415681 gdk_window_clear_area includes an extra line and column o...
  - 418219 GtkRecentChooser should apply filter before sorting and c...
  - 418403 Scroll to printer after selecting it from settings
  - 421985 _gtk_print_operation_platform_backend_launch_preview
  - 421990 gtk_print_job_get_surface
  - 421993 gtk_print_operation_init
  - 423064 Conditional jump or move depends on uninitialised value(s...
  - 423722 Fix printing header in gtk-demo
  - 424168 gtk_print_operation_run on async preview
  - 425655 Don't install gtk+-unix-print-2.0.pc on non-UNIX platforms
  - 425786 GDK segfaults if XineramaQueryScreens fails
  - 428665 Lpr Backend gets stuck in infinite loop during gtk_enumer...
  - 429902 GtkPrintOperation leaks cairo contextes
  - 431997 First delay of GdkPixbufAnimationIter is wrong
  - 433242 Inconsistent scroll arrow position calculations
  - 433972 Placing gtk.Expander inside a gtk.TextView() changes gtk....
  - 434261 _gtk_toolbar_elide_underscores incorrectly handles some s...
  - 383354 ctrl-L should make 'Location' entry disappear
  - 418673 gtk_recent_manager_add_item
  - 429732 gtk_accel_group_finalize accesses invalid memory
  - 435028 WM_CLIENT_LEADER is wrong on the leader_window
  - 431067 Background of the header window is not updated
  - 338843 add recent files support inside the ui manager
  - 148535 add drop shadow to menus, tooltips, etc. under Windows XP
* debian/control.in:
  - Conflicts on ubuntulooks (<= 0.9.11-1)
* debian/patches/15_default-fallback-icon-theme.patch:
  - patch from Debian, fallback on gnome icon theme

Show diffs side-by-side

added added

removed removed

Lines of Context:
gdk/x11/gdkpixmap-x11.c
 
1
/* GDK - The GIMP Drawing Kit
 
2
 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
 
3
 *
 
4
 * This library is free software; you can redistribute it and/or
 
5
 * modify it under the terms of the GNU Lesser General Public
 
6
 * License as published by the Free Software Foundation; either
 
7
 * version 2 of the License, or (at your option) any later version.
 
8
 *
 
9
 * This library is distributed in the hope that it will be useful,
 
10
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
12
 * Lesser General Public License for more details.
 
13
 *
 
14
 * You should have received a copy of the GNU Lesser General Public
 
15
 * License along with this library; if not, write to the
 
16
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 
17
 * Boston, MA 02111-1307, USA.
 
18
 */
 
19
 
 
20
/*
 
21
 * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
 
22
 * file for a list of people on the GTK+ Team.  See the ChangeLog
 
23
 * files for a list of changes.  These files are distributed with
 
24
 * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 
 
25
 */
 
26
 
 
27
#include <config.h>
 
28
#include <stdlib.h>
 
29
#include <stdio.h>
 
30
#include <string.h>
 
31
/* Needed for SEEK_END in SunOS */
 
32
#include <unistd.h>
 
33
#include <X11/Xlib.h>
 
34
 
 
35
#include "gdkx.h"
 
36
 
 
37
#include "gdkpixmap-x11.h"
 
38
#include "gdkprivate-x11.h"
 
39
#include "gdkscreen-x11.h"
 
40
#include "gdkdisplay-x11.h"
 
41
 
 
42
#include <gdk/gdkinternals.h>
 
43
#include "gdkalias.h"
 
44
 
 
45
typedef struct
 
46
{
 
47
  gchar *color_string;
 
48
  GdkColor color;
 
49
  gint transparent;
 
50
} _GdkPixmapColor;
 
51
 
 
52
typedef struct
 
53
{
 
54
  guint ncolors;
 
55
  GdkColormap *colormap;
 
56
  gulong pixels[1];
 
57
} _GdkPixmapInfo;
 
58
 
 
59
static void gdk_pixmap_impl_x11_get_size   (GdkDrawable        *drawable,
 
60
                                        gint               *width,
 
61
                                        gint               *height);
 
62
 
 
63
static void gdk_pixmap_impl_x11_dispose    (GObject            *object);
 
64
static void gdk_pixmap_impl_x11_finalize   (GObject            *object);
 
65
 
 
66
G_DEFINE_TYPE (GdkPixmapImplX11, gdk_pixmap_impl_x11, GDK_TYPE_DRAWABLE_IMPL_X11)
 
67
 
 
68
GType
 
69
_gdk_pixmap_impl_get_type (void)
 
70
{
 
71
  return gdk_pixmap_impl_x11_get_type ();
 
72
}
 
73
 
 
74
static void
 
75
gdk_pixmap_impl_x11_init (GdkPixmapImplX11 *impl)
 
76
{
 
77
  impl->width = 1;
 
78
  impl->height = 1;
 
79
}
 
80
 
 
81
static void
 
82
gdk_pixmap_impl_x11_class_init (GdkPixmapImplX11Class *klass)
 
83
{
 
84
  GObjectClass *object_class = G_OBJECT_CLASS (klass);
 
85
  GdkDrawableClass *drawable_class = GDK_DRAWABLE_CLASS (klass);
 
86
  
 
87
  object_class->dispose  = gdk_pixmap_impl_x11_dispose;
 
88
  object_class->finalize = gdk_pixmap_impl_x11_finalize;
 
89
 
 
90
  drawable_class->get_size = gdk_pixmap_impl_x11_get_size;
 
91
}
 
92
 
 
93
static void
 
94
gdk_pixmap_impl_x11_dispose (GObject *object)
 
95
{
 
96
  GdkPixmapImplX11 *impl = GDK_PIXMAP_IMPL_X11 (object);
 
97
  GdkPixmap *wrapper = GDK_PIXMAP (GDK_DRAWABLE_IMPL_X11 (impl)->wrapper);
 
98
  GdkDisplay *display = GDK_PIXMAP_DISPLAY (wrapper);
 
99
 
 
100
  if (!display->closed)
 
101
    {
 
102
      if (!impl->is_foreign)
 
103
        XFreePixmap (GDK_DISPLAY_XDISPLAY (display), GDK_PIXMAP_XID (wrapper));
 
104
    }
 
105
 
 
106
  _gdk_xid_table_remove (display, GDK_PIXMAP_XID (wrapper));
 
107
 
 
108
  G_OBJECT_CLASS (gdk_pixmap_impl_x11_parent_class)->dispose (object);
 
109
}
 
110
 
 
111
static void
 
112
gdk_pixmap_impl_x11_finalize (GObject *object)
 
113
{
 
114
  GdkPixmapImplX11 *impl = GDK_PIXMAP_IMPL_X11 (object);
 
115
  GdkPixmap *wrapper = GDK_PIXMAP (GDK_DRAWABLE_IMPL_X11 (impl)->wrapper);
 
116
  GdkDisplay *display = GDK_PIXMAP_DISPLAY (wrapper);
 
117
 
 
118
  if (!display->closed)
 
119
    {
 
120
      GdkDrawableImplX11 *draw_impl = GDK_DRAWABLE_IMPL_X11 (impl);
 
121
 
 
122
      _gdk_x11_drawable_finish (GDK_DRAWABLE (draw_impl));
 
123
    }
 
124
 
 
125
  G_OBJECT_CLASS (gdk_pixmap_impl_x11_parent_class)->finalize (object);
 
126
}
 
127
 
 
128
static void
 
129
gdk_pixmap_impl_x11_get_size   (GdkDrawable *drawable,
 
130
                                gint        *width,
 
131
                                gint        *height)
 
132
{
 
133
  if (width)
 
134
    *width = GDK_PIXMAP_IMPL_X11 (drawable)->width;
 
135
  if (height)
 
136
    *height = GDK_PIXMAP_IMPL_X11 (drawable)->height;
 
137
}
 
138
 
 
139
GdkPixmap*
 
140
gdk_pixmap_new (GdkDrawable *drawable,
 
141
                gint         width,
 
142
                gint         height,
 
143
                gint         depth)
 
144
{
 
145
  GdkPixmap *pixmap;
 
146
  GdkDrawableImplX11 *draw_impl;
 
147
  GdkPixmapImplX11 *pix_impl;
 
148
  GdkColormap *cmap;
 
149
  gint window_depth;
 
150
  
 
151
  g_return_val_if_fail (drawable == NULL || GDK_IS_DRAWABLE (drawable), NULL);
 
152
  g_return_val_if_fail ((drawable != NULL) || (depth != -1), NULL);
 
153
  g_return_val_if_fail ((width != 0) && (height != 0), NULL);
 
154
  
 
155
  if (!drawable)
 
156
    {
 
157
      GDK_NOTE (MULTIHEAD, g_message ("need to specify the screen parent window "
 
158
                                      "for gdk_pixmap_new() to be multihead safe"));
 
159
      drawable = gdk_screen_get_root_window (gdk_screen_get_default ());
 
160
    }
 
161
 
 
162
  if (GDK_IS_WINDOW (drawable) && GDK_WINDOW_DESTROYED (drawable))
 
163
    return NULL;
 
164
 
 
165
  window_depth = gdk_drawable_get_depth (GDK_DRAWABLE (drawable));
 
166
  if (depth == -1)
 
167
    depth = window_depth;
 
168
 
 
169
  pixmap = g_object_new (gdk_pixmap_get_type (), NULL);
 
170
  draw_impl = GDK_DRAWABLE_IMPL_X11 (GDK_PIXMAP_OBJECT (pixmap)->impl);
 
171
  pix_impl = GDK_PIXMAP_IMPL_X11 (GDK_PIXMAP_OBJECT (pixmap)->impl);
 
172
  draw_impl->wrapper = GDK_DRAWABLE (pixmap);
 
173
  
 
174
  draw_impl->screen = GDK_WINDOW_SCREEN (drawable);
 
175
  draw_impl->xid = XCreatePixmap (GDK_PIXMAP_XDISPLAY (pixmap),
 
176
                                  GDK_WINDOW_XID (drawable),
 
177
                                  width, height, depth);
 
178
  
 
179
  pix_impl->is_foreign = FALSE;
 
180
  pix_impl->width = width;
 
181
  pix_impl->height = height;
 
182
  GDK_PIXMAP_OBJECT (pixmap)->depth = depth;
 
183
 
 
184
  if (depth == window_depth)
 
185
    {
 
186
      cmap = gdk_drawable_get_colormap (drawable);
 
187
      if (cmap)
 
188
        gdk_drawable_set_colormap (pixmap, cmap);
 
189
    }
 
190
  
 
191
  _gdk_xid_table_insert (GDK_WINDOW_DISPLAY (drawable), 
 
192
                         &GDK_PIXMAP_XID (pixmap), pixmap);
 
193
  return pixmap;
 
194
}
 
195
 
 
196
GdkPixmap *
 
197
gdk_bitmap_create_from_data (GdkDrawable *drawable,
 
198
                             const gchar *data,
 
199
                             gint         width,
 
200
                             gint         height)
 
201
{
 
202
  GdkPixmap *pixmap;
 
203
  GdkDrawableImplX11 *draw_impl;
 
204
  GdkPixmapImplX11 *pix_impl;
 
205
  
 
206
  g_return_val_if_fail (data != NULL, NULL);
 
207
  g_return_val_if_fail ((width != 0) && (height != 0), NULL);
 
208
  g_return_val_if_fail (drawable == NULL || GDK_IS_DRAWABLE (drawable), NULL);
 
209
 
 
210
  if (!drawable)
 
211
    {
 
212
      GDK_NOTE (MULTIHEAD, g_message ("need to specify the screen parent window "
 
213
                                     "for gdk_bitmap_create_from_data() to be multihead safe"));
 
214
      drawable = gdk_screen_get_root_window (gdk_screen_get_default ());
 
215
    }
 
216
  
 
217
  if (GDK_IS_WINDOW (drawable) && GDK_WINDOW_DESTROYED (drawable))
 
218
    return NULL;
 
219
 
 
220
  pixmap = g_object_new (gdk_pixmap_get_type (), NULL);
 
221
  draw_impl = GDK_DRAWABLE_IMPL_X11 (GDK_PIXMAP_OBJECT (pixmap)->impl);
 
222
  pix_impl = GDK_PIXMAP_IMPL_X11 (GDK_PIXMAP_OBJECT (pixmap)->impl);
 
223
  draw_impl->wrapper = GDK_DRAWABLE (pixmap);
 
224
 
 
225
  pix_impl->is_foreign = FALSE;
 
226
  pix_impl->width = width;
 
227
  pix_impl->height = height;
 
228
  GDK_PIXMAP_OBJECT (pixmap)->depth = 1;
 
229
 
 
230
  draw_impl->screen = GDK_WINDOW_SCREEN (drawable);
 
231
  draw_impl->xid = XCreateBitmapFromData (GDK_WINDOW_XDISPLAY (drawable),
 
232
                                          GDK_WINDOW_XID (drawable),
 
233
                                          (char *)data, width, height);
 
234
 
 
235
  _gdk_xid_table_insert (GDK_WINDOW_DISPLAY (drawable), 
 
236
                         &GDK_PIXMAP_XID (pixmap), pixmap);
 
237
  return pixmap;
 
238
}
 
239
 
 
240
GdkPixmap*
 
241
gdk_pixmap_create_from_data (GdkDrawable    *drawable,
 
242
                             const gchar    *data,
 
243
                             gint            width,
 
244
                             gint            height,
 
245
                             gint            depth,
 
246
                             const GdkColor *fg,
 
247
                             const GdkColor *bg)
 
248
{
 
249
  GdkPixmap *pixmap;
 
250
  GdkDrawableImplX11 *draw_impl;
 
251
  GdkPixmapImplX11 *pix_impl;
 
252
 
 
253
  g_return_val_if_fail (drawable == NULL || GDK_IS_DRAWABLE (drawable), NULL);
 
254
  g_return_val_if_fail (data != NULL, NULL);
 
255
  g_return_val_if_fail (fg != NULL, NULL);
 
256
  g_return_val_if_fail (bg != NULL, NULL);
 
257
  g_return_val_if_fail ((drawable != NULL) || (depth != -1), NULL);
 
258
  g_return_val_if_fail ((width != 0) && (height != 0), NULL);
 
259
 
 
260
  if (!drawable)
 
261
    {
 
262
      GDK_NOTE (MULTIHEAD, g_message ("need to specify the screen parent window"
 
263
                                      "for gdk_pixmap_create_from_data() to be multihead safe"));
 
264
      drawable = gdk_screen_get_root_window (gdk_screen_get_default ());
 
265
    }
 
266
 
 
267
  if (GDK_IS_WINDOW (drawable) && GDK_WINDOW_DESTROYED (drawable))
 
268
    return NULL;
 
269
 
 
270
  if (depth == -1)
 
271
    depth = gdk_drawable_get_visual (drawable)->depth;
 
272
 
 
273
  pixmap = g_object_new (gdk_pixmap_get_type (), NULL);
 
274
  draw_impl = GDK_DRAWABLE_IMPL_X11 (GDK_PIXMAP_OBJECT (pixmap)->impl);
 
275
  pix_impl = GDK_PIXMAP_IMPL_X11 (GDK_PIXMAP_OBJECT (pixmap)->impl);
 
276
  draw_impl->wrapper = GDK_DRAWABLE (pixmap);
 
277
  
 
278
  pix_impl->is_foreign = FALSE;
 
279
  pix_impl->width = width;
 
280
  pix_impl->height = height;
 
281
  GDK_PIXMAP_OBJECT (pixmap)->depth = depth;
 
282
 
 
283
  draw_impl->screen = GDK_DRAWABLE_SCREEN (drawable);
 
284
  draw_impl->xid = XCreatePixmapFromBitmapData (GDK_WINDOW_XDISPLAY (drawable),
 
285
                                                GDK_WINDOW_XID (drawable),
 
286
                                                (char *)data, width, height,
 
287
                                                fg->pixel, bg->pixel, depth);
 
288
 
 
289
  _gdk_xid_table_insert (GDK_WINDOW_DISPLAY (drawable),
 
290
                         &GDK_PIXMAP_XID (pixmap), pixmap);
 
291
  return pixmap;
 
292
}
 
293
 
 
294
/**
 
295
 * gdk_pixmap_foreign_new_for_display:
 
296
 * @display: The #GdkDisplay where @anid is located.
 
297
 * @anid: a native pixmap handle.
 
298
 * 
 
299
 * Wraps a native pixmap in a #GdkPixmap.
 
300
 * This may fail if the pixmap has been destroyed.
 
301
 *
 
302
 * For example in the X backend, a native pixmap handle is an Xlib
 
303
 * <type>XID</type>.
 
304
 *
 
305
 * Return value: the newly-created #GdkPixmap wrapper for the 
 
306
 *    native pixmap or %NULL if the pixmap has been destroyed.
 
307
 *
 
308
 * Since: 2.2
 
309
 **/
 
310
GdkPixmap *
 
311
gdk_pixmap_foreign_new_for_display (GdkDisplay      *display,
 
312
                                    GdkNativeWindow  anid)
 
313
{
 
314
  Pixmap xpixmap;
 
315
  Window root_return;
 
316
  GdkScreen *screen;
 
317
  int x_ret, y_ret;
 
318
  unsigned int w_ret, h_ret, bw_ret, depth_ret;
 
319
 
 
320
  g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
 
321
 
 
322
  /* check to make sure we were passed something at
 
323
   * least a little sane */
 
324
  g_return_val_if_fail ((anid != 0), NULL);
 
325
  
 
326
  /* set the pixmap to the passed in value */
 
327
  xpixmap = anid;
 
328
 
 
329
  /* get information about the Pixmap to fill in the structure for
 
330
     the gdk window */
 
331
  if (!XGetGeometry (GDK_DISPLAY_XDISPLAY (display),
 
332
                     xpixmap, &root_return,
 
333
                     &x_ret, &y_ret, &w_ret, &h_ret, &bw_ret, &depth_ret))
 
334
    return NULL;
 
335
  
 
336
  screen = _gdk_x11_display_screen_for_xrootwin (display, root_return);
 
337
  return gdk_pixmap_foreign_new_for_screen (screen, anid, w_ret, h_ret, depth_ret);
 
338
}
 
339
 
 
340
/**
 
341
 * gdk_pixmap_foreign_new_for_screen:
 
342
 * @screen: a #GdkScreen
 
343
 * @anid: a native pixmap handle
 
344
 * @width: the width of the pixmap identified by @anid
 
345
 * @height: the height of the pixmap identified by @anid
 
346
 * @depth: the depth of the pixmap identified by @anid
 
347
 *
 
348
 * Wraps a native pixmap in a #GdkPixmap.
 
349
 * This may fail if the pixmap has been destroyed.
 
350
 *
 
351
 * For example in the X backend, a native pixmap handle is an Xlib
 
352
 * <type>XID</type>.
 
353
 *
 
354
 * This function is an alternative to gdk_pixmap_foreign_new_for_display()
 
355
 * for cases where the dimensions of the pixmap are known. For the X
 
356
 * backend, this avoids a roundtrip to the server.
 
357
 *
 
358
 * Return value: the newly-created #GdkPixmap wrapper for the 
 
359
 *    native pixmap or %NULL if the pixmap has been destroyed.
 
360
 * 
 
361
 * Since: 2.10
 
362
 */
 
363
GdkPixmap *
 
364
gdk_pixmap_foreign_new_for_screen (GdkScreen       *screen,
 
365
                                   GdkNativeWindow  anid,
 
366
                                   gint             width,
 
367
                                   gint             height,
 
368
                                   gint             depth)
 
369
{
 
370
  Pixmap xpixmap;
 
371
  GdkPixmap *pixmap;
 
372
  GdkDrawableImplX11 *draw_impl;
 
373
  GdkPixmapImplX11 *pix_impl;
 
374
 
 
375
  g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
 
376
  g_return_val_if_fail (anid != 0, NULL);
 
377
  g_return_val_if_fail (width > 0, NULL);
 
378
  g_return_val_if_fail (height > 0, NULL);
 
379
  g_return_val_if_fail (depth > 0, NULL);
 
380
 
 
381
  pixmap = g_object_new (gdk_pixmap_get_type (), NULL);
 
382
  draw_impl = GDK_DRAWABLE_IMPL_X11 (GDK_PIXMAP_OBJECT (pixmap)->impl);
 
383
  pix_impl = GDK_PIXMAP_IMPL_X11 (GDK_PIXMAP_OBJECT (pixmap)->impl);
 
384
  draw_impl->wrapper = GDK_DRAWABLE (pixmap);
 
385
 
 
386
  xpixmap = anid;
 
387
  
 
388
  draw_impl->screen = screen;
 
389
  draw_impl->xid = xpixmap;
 
390
 
 
391
  pix_impl->is_foreign = TRUE;
 
392
  pix_impl->width = width;
 
393
  pix_impl->height = height;
 
394
  GDK_PIXMAP_OBJECT (pixmap)->depth = depth;
 
395
  
 
396
  _gdk_xid_table_insert (gdk_screen_get_display (screen), 
 
397
                         &GDK_PIXMAP_XID (pixmap), pixmap);
 
398
 
 
399
  return pixmap;
 
400
}
 
401
 
 
402
/**
 
403
 * gdk_pixmap_foreign_new:
 
404
 * @anid: a native pixmap handle.
 
405
 * 
 
406
 * Wraps a native window for the default display in a #GdkPixmap.
 
407
 * This may fail if the pixmap has been destroyed.
 
408
 *
 
409
 * For example in the X backend, a native pixmap handle is an Xlib
 
410
 * <type>XID</type>.
 
411
 *
 
412
 * Return value: the newly-created #GdkPixmap wrapper for the 
 
413
 *    native pixmap or %NULL if the pixmap has been destroyed.
 
414
 **/
 
415
GdkPixmap*
 
416
gdk_pixmap_foreign_new (GdkNativeWindow anid)
 
417
{
 
418
   return gdk_pixmap_foreign_new_for_display (gdk_display_get_default (), anid);
 
419
}
 
420
 
 
421
/**
 
422
 * gdk_pixmap_lookup:
 
423
 * @anid: a native pixmap handle.
 
424
 * 
 
425
 * Looks up the #GdkPixmap that wraps the given native pixmap handle.
 
426
 *
 
427
 * For example in the X backend, a native pixmap handle is an Xlib
 
428
 * <type>XID</type>.
 
429
 *
 
430
 * Return value: the #GdkWindow wrapper for the native window,
 
431
 *    or %NULL if there is none.
 
432
 **/
 
433
GdkPixmap*
 
434
gdk_pixmap_lookup (GdkNativeWindow anid)
 
435
{
 
436
  return (GdkPixmap*) gdk_xid_table_lookup_for_display (gdk_display_get_default (), anid);
 
437
}
 
438
 
 
439
/**
 
440
 * gdk_pixmap_lookup_for_display:
 
441
 * @display: the #GdkDisplay associated with @anid
 
442
 * @anid: a native pixmap handle.
 
443
 * 
 
444
 * Looks up the #GdkPixmap that wraps the given native pixmap handle.
 
445
 *
 
446
 * For example in the X backend, a native pixmap handle is an Xlib
 
447
 * <type>XID</type>.
 
448
 *
 
449
 * Return value: the #GdkPixmap wrapper for the native pixmap,
 
450
 *    or %NULL if there is none.
 
451
 *
 
452
 * Since: 2.2
 
453
 **/
 
454
GdkPixmap*
 
455
gdk_pixmap_lookup_for_display (GdkDisplay *display, GdkNativeWindow anid)
 
456
{
 
457
  g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
 
458
  return (GdkPixmap*) gdk_xid_table_lookup_for_display (display, anid);
 
459
}
 
460
 
 
461
#define __GDK_PIXMAP_X11_C__
 
462
#include  "gdkaliasdef.c"