static void gdk_quartz_draw_drawable (GdkDrawable *drawable, GdkGC *gc, GdkPixmap *src, gint xsrc, gint ysrc, gint xdest, gint ydest, gint width, gint height, GdkDrawable *original_src) { int src_depth = gdk_drawable_get_depth (src); int dest_depth = gdk_drawable_get_depth (drawable); GdkDrawableImplQuartz *src_impl; if (GDK_IS_WINDOW_IMPL_QUARTZ (src)) { GdkWindowImplQuartz *window_impl; window_impl = GDK_WINDOW_IMPL_QUARTZ (src); /* We do support moving areas on the same drawable, if it can be done * by using a scroll. FIXME: We need to check that the params support * this hack, and make sure it's done properly with any offsets etc? */ if (drawable == (GdkDrawable *)window_impl) { [window_impl->view scrollRect:NSMakeRect (xsrc, ysrc, width, height) by:NSMakeSize (xdest - xsrc, ydest - ysrc)]; } else
static cairo_t * gdk_cairo_create (GdkDrawable *drawable) { int width, height; cairo_t *cr = NULL; cairo_surface_t *surface = NULL; GdkVisual *visual = gdk_drawable_get_visual (drawable); gdk_drawable_get_size (drawable, &width, &height); if (visual) surface = cairo_xlib_surface_create (GDK_DRAWABLE_XDISPLAY (drawable), GDK_DRAWABLE_XID (drawable), GDK_VISUAL_XVISUAL (visual), width, height); else if (gdk_drawable_get_depth (drawable) == 1) surface = cairo_xlib_surface_create_for_bitmap (GDK_PIXMAP_XDISPLAY (drawable), GDK_PIXMAP_XID (drawable), GDK_SCREEN_XSCREEN (gdk_drawable_get_screen (drawable)), width, height); else { g_warning ("Using Cairo rendering requires the drawable argument to\n" "have a specified colormap. All windows have a colormap,\n" "however, pixmaps only have colormap by default if they\n" "were created with a non-NULL window argument. Otherwise\n" "a colormap must be set on them with " "gdk_drawable_set_colormap"); return NULL; } if (surface) { cr = cairo_create (surface); cairo_surface_destroy (surface); } return cr; }
void GtkPaintContext::updatePixmap(GtkWidget *area, int w, int h) { if ((myPixmap != 0) && ((myWidth != w) || (myHeight != h))) { gdk_pixmap_unref(myPixmap); myPixmap = 0; if (myTextGC != 0) { gdk_gc_unref(myTextGC); gdk_gc_unref(myFillGC); gdk_gc_unref(myBackGC); myTextGC = 0; myFillGC = 0; myBackGC = 0; } } if (myPixmap == 0) { myWidth = w; myHeight = h; myPixmap = gdk_pixmap_new(area->window, myWidth, myHeight, gdk_drawable_get_depth(area->window)); } if (myTextGC == 0) { myTextGC = gdk_gc_new(myPixmap); myFillGC = gdk_gc_new(myPixmap); myBackGC = gdk_gc_new(myPixmap); } if (myContext == 0) { myContext = gtk_widget_get_pango_context(area); if (myFontDescription != 0) { myAnalysis.font = pango_context_load_font(myContext, myFontDescription); myAnalysis.shape_engine = pango_font_find_shaper(myAnalysis.font, 0, 0); } } }
static int gdk_quartz_get_depth (GdkDrawable *drawable) { /* This is a bit bogus but I'm not sure the other way is better */ return gdk_drawable_get_depth (GDK_DRAWABLE_IMPL_QUARTZ (drawable)->wrapper); }
GdkPixbuf * meta_ui_get_pixbuf_from_pixmap (Pixmap pmap) { GdkPixmap *gpmap; GdkScreen *screen; GdkPixbuf *pixbuf; GdkColormap *cmap; int width, height, depth; gpmap = gdk_pixmap_foreign_new (pmap); screen = gdk_drawable_get_screen (gpmap); gdk_drawable_get_size (GDK_DRAWABLE (gpmap), &width, &height); depth = gdk_drawable_get_depth (GDK_DRAWABLE (gpmap)); if (depth <= 24) cmap = gdk_screen_get_rgb_colormap (screen); else cmap = gdk_screen_get_rgba_colormap (screen); pixbuf = gdk_pixbuf_get_from_drawable (NULL, gpmap, cmap, 0, 0, 0, 0, width, height); g_object_unref (gpmap); return pixbuf; }
XRenderPictFormat * get_format_for_drawable (decor_t *d, GdkDrawable *drawable) { if (!d->frame_window || gdk_drawable_get_depth (drawable) == 32) return xformat_rgba; return xformat_rgb; }
static GdkColormap* get_cmap (GdkPixmap *pixmap) { GdkColormap *cmap; cmap = gdk_drawable_get_colormap (pixmap); if (cmap) g_object_ref (G_OBJECT (cmap)); if (cmap == NULL) { if (gdk_drawable_get_depth (pixmap) == 1) { /* try null cmap */ cmap = NULL; } else { /* Try system cmap */ GdkScreen *screen = gdk_drawable_get_screen (GDK_DRAWABLE (pixmap)); cmap = gdk_screen_get_system_colormap (screen); g_object_ref (G_OBJECT (cmap)); } } /* Be sure we aren't going to blow up due to visual mismatch */ if (cmap && #if GTK_CHECK_VERSION(2,21,0) (gdk_visual_get_depth (gdk_colormap_get_visual (cmap)) != gdk_drawable_get_depth (pixmap)) #else (gdk_colormap_get_visual (cmap)->depth != gdk_drawable_get_depth (pixmap)) #endif ) { g_object_unref (G_OBJECT (cmap)); cmap = NULL; } return cmap; }
GdkColormap * get_colormap_for_drawable (GdkDrawable *d) { GdkDisplay *display = gdk_display_get_default (); GdkScreen *screen = gdk_display_get_default_screen (display); if (gdk_drawable_get_depth (d) == 32) return gdk_screen_get_rgba_colormap (screen); return gdk_screen_get_rgb_colormap (screen); }
cdCtxCanvas *cdgdkCreateCanvas(cdCanvas* canvas, GdkDrawable* wnd, GdkScreen* scr, GdkVisual* vis) { cdCtxCanvas *ctxcanvas = (cdCtxCanvas *)malloc(sizeof(cdCtxCanvas)); memset(ctxcanvas, 0, sizeof(cdCtxCanvas)); ctxcanvas->scr = scr; ctxcanvas->vis = vis; ctxcanvas->wnd = wnd; ctxcanvas->gc = gdk_gc_new(wnd); if (!ctxcanvas->gc) { free(canvas); return NULL; } ctxcanvas->fontcontext = gdk_pango_context_get(); #if PANGO_VERSION_CHECK(1,16,0) pango_context_set_language(ctxcanvas->fontcontext, pango_language_get_default()); #endif ctxcanvas->canvas = canvas; canvas->ctxcanvas = ctxcanvas; gdk_drawable_get_size(wnd, &ctxcanvas->canvas->w, &ctxcanvas->canvas->h); ctxcanvas->depth = gdk_drawable_get_depth(wnd); canvas->bpp = ctxcanvas->depth; canvas->xres = ((double)gdk_screen_get_width(scr) / (double)gdk_screen_get_width_mm(scr)); canvas->yres = ((double)gdk_screen_get_height(scr) / (double)gdk_screen_get_height_mm(scr)); canvas->w_mm = ((double)canvas->w) / canvas->xres; canvas->h_mm = ((double)canvas->h) / canvas->yres; canvas->invert_yaxis = 1; if (canvas->bpp <= 8) { ctxcanvas->colormap = gdk_gc_get_colormap(ctxcanvas->gc); if (!ctxcanvas->colormap) { ctxcanvas->colormap = gdk_colormap_get_system(); gdk_gc_set_colormap(ctxcanvas->gc, ctxcanvas->colormap); } ctxcanvas->num_colors = ctxcanvas->colormap->size; } cdRegisterAttribute(canvas, &gc_attrib); cdRegisterAttribute(canvas, &rotate_attrib); cdRegisterAttribute(canvas, &pangoversion_attrib); cdRegisterAttribute(canvas, &imgdither_attrib); cdRegisterAttribute(canvas, &interp_attrib); return ctxcanvas; }
gchar * _gdk_win32_drawable_description (GdkDrawable *d) { gint width, height, depth; gdk_drawable_get_size (d, &width, &height); depth = gdk_drawable_get_depth (d); return static_printf ("%s:%p:%dx%dx%d", G_OBJECT_TYPE_NAME (d), GDK_DRAWABLE_HANDLE (d), width, height, depth); }
void iupDrawUpdateSize(IdrawCanvas* dc) { int w, h; gdk_drawable_get_size(dc->wnd, &w, &h); if (w != dc->w || h != dc->h) { g_object_unref(dc->pixmap_gc); g_object_unref(dc->pixmap); dc->pixmap = gdk_pixmap_new(dc->wnd, dc->w, dc->h, gdk_drawable_get_depth(dc->wnd)); dc->pixmap_gc = gdk_gc_new(dc->pixmap); } }
IdrawCanvas* iupdrvDrawCreateCanvas(Ihandle* ih) { IdrawCanvas* dc = calloc(1, sizeof(IdrawCanvas)); dc->ih = ih; dc->wnd = (GdkWindow*)IupGetAttribute(ih, "DRAWABLE"); dc->gc = gdk_gc_new(dc->wnd); gdk_drawable_get_size(dc->wnd, &dc->w, &dc->h); dc->pixmap = gdk_pixmap_new(dc->wnd, dc->w, dc->h, gdk_drawable_get_depth(dc->wnd)); dc->pixmap_gc = gdk_gc_new(dc->pixmap); return dc; }
IdrawCanvas* iupDrawCreateCanvas(Ihandle* ih) { IdrawCanvas* dc = calloc(1, sizeof(IdrawCanvas)); dc->ih = ih; dc->wnd = iupgtkGetWindow(ih->handle); dc->gc = gdk_gc_new(dc->wnd); gdk_drawable_get_size(dc->wnd, &dc->w, &dc->h); dc->pixmap = gdk_pixmap_new(dc->wnd, dc->w, dc->h, gdk_drawable_get_depth(dc->wnd)); dc->pixmap_gc = gdk_gc_new(dc->pixmap); return dc; }
static GdkColormap* get_cmap (GdkPixmap *pixmap) { GdkColormap *cmap; cmap = gdk_drawable_get_colormap (pixmap); if (cmap) g_object_ref (G_OBJECT (cmap)); if (cmap == NULL) { if (gdk_drawable_get_depth (pixmap) == 1) { meta_verbose ("Using NULL colormap for snapshotting bitmap\n"); cmap = NULL; } else { meta_verbose ("Using system cmap to snapshot pixmap\n"); cmap = gdk_screen_get_system_colormap (gdk_drawable_get_screen (pixmap)); g_object_ref (G_OBJECT (cmap)); } } /* Be sure we aren't going to blow up due to visual mismatch */ if (cmap && (gdk_colormap_get_visual (cmap)->depth != gdk_drawable_get_depth (pixmap))) { cmap = NULL; meta_verbose ("Switching back to NULL cmap because of depth mismatch\n"); } return cmap; }
static gboolean cairo_menu_item_expose (GtkWidget *widget,GdkEventExpose *event) { CairoMenuItemPrivate * priv = GET_PRIVATE(widget); if (priv->cairo_style) { PangoLayout *layout; double x,y,width,height; gchar * label; g_object_get (widget, "label",&label, NULL); cairo_t * cr = gdk_cairo_create (widget->window); g_debug ("%s: bit depth = %d",__func__,gdk_drawable_get_depth (widget->window)); // g_debug ("Region %d,%d: %dx%d",event->area.x, event->area.y,event->area.width, event->area.height); x = event->area.x; y = event->area.y; width = event->area.width; height = event->area.height; cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE); cairo_set_source_rgba (cr,0.0,1.0,0.0,0.1); cairo_rectangle (cr, x,y,width,height); cairo_fill (cr); layout = pango_cairo_create_layout (cr); pango_font_description_set_absolute_size (priv->font_description, height * 0.8 * PANGO_SCALE); pango_layout_set_font_description (layout, priv->font_description); pango_layout_set_text (layout, label, -1); cairo_set_source_rgba (cr,1.0,1.0,1.0,0.3); cairo_move_to (cr,x+height * 1.1,y+height*0.1); pango_cairo_show_layout (cr, layout); cairo_destroy (cr); g_object_unref (layout); g_free (label); return TRUE; } else { return FALSE; } }
GdkPixmap * create_native_pixmap_and_wrap (int w, int h, GtkWidget *parent_style_window) { GdkWindow *window; if (w <= 0 || h <= 0) abort (); window = gtk_widget_get_window (parent_style_window); GdkPixmap *pixmap = gdk_pixmap_foreign_new (XCreatePixmap (gdk_x11_display_get_xdisplay (gdk_display_get_default ()), GDK_WINDOW_XID (window), w, h, gdk_drawable_get_depth (window))); GdkColormap *cmap = get_colormap_for_drawable (GDK_DRAWABLE (pixmap)); gdk_drawable_set_colormap (GDK_DRAWABLE (pixmap), cmap); return pixmap; }
GdkPixbuf* meta_ui_get_pixbuf_from_pixmap(Pixmap pmap) { GdkPixmap* gpmap; GdkScreen* screen; GdkPixbuf* pixbuf; #if !GTK_CHECK_VERSION (3, 0, 0) GdkColormap* cmap; #endif int width; int height; int depth; gpmap = gdk_pixmap_foreign_new(pmap); screen = gdk_drawable_get_screen(gpmap); #if GTK_CHECK_VERSION(3, 0, 0) width = gdk_window_get_width(GDK_WINDOW(gpmap)); height = gdk_window_get_height(GDK_WINDOW(gpmap)); #else gdk_drawable_get_size(GDK_DRAWABLE(gpmap), &width, &height); #endif depth = gdk_drawable_get_depth(GDK_DRAWABLE(gpmap)); #if !GTK_CHECK_VERSION (3, 0, 0) if (depth <= 24) { cmap = gdk_screen_get_system_colormap(screen); } else { cmap = gdk_screen_get_rgba_colormap(screen); } #endif pixbuf = gdk_pixbuf_get_from_drawable(NULL, gpmap, cmap, 0, 0, 0, 0, width, height); g_object_unref(gpmap); return pixbuf; }
void ZLGtkPaintContext::setFillColor(ZLColor color, FillStyle style) { if (style == SOLID_FILL) { ::setColor(myFillGC, color); gdk_gc_set_fill(myFillGC, GDK_SOLID); } else { gdk_gc_set_fill(myFillGC, GDK_TILED); if (myPixmap != 0) { if (myTilePixmap != 0) { gdk_pixmap_unref(myTilePixmap); } static GdkColor fgColor; ::setColor(fgColor, color); static GdkColor bgColor; ::setColor(bgColor, myBackColor); static char data[] = { 0x0C, 0x0C, 0x03, 0x03 }; myTilePixmap = gdk_pixmap_create_from_data( myPixmap, data, 4, 4, gdk_drawable_get_depth(myPixmap), &fgColor, &bgColor ); gdk_gc_set_tile(myFillGC, myTilePixmap); } } }
static gboolean cairo_menu_expose (GtkWidget *widget,GdkEventExpose *event) { struct { GtkWidget *container; GdkEventExpose *event; } data; CairoMenuPrivate * priv = GET_PRIVATE(widget); data.container = widget; data.event = event; if (priv->cairo_style) { double x,y,width,height; cairo_t * cr = gdk_cairo_create (widget->window); g_debug ("%s: bit depth = %d",__func__,gdk_drawable_get_depth (widget->window)); //g_debug ("Region %d,%d: %dx%d",event->area.x, event->area.y,event->area.width, event->area.height); x = event->area.x; y = event->area.y; width = event->area.width; height = event->area.height; cairo_set_source_rgba (cr,1.0,0.0,0.0,0.5); cairo_rectangle (cr, x,y,width,height); cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE); cairo_fill (cr); gtk_container_forall (GTK_CONTAINER (widget),_expose_child,&data); cairo_destroy (cr); return TRUE; } else { return FALSE; } }
static gboolean bb_sample_widget_expose_event (GtkWidget *widget, GdkEventExpose *expose) { BbSampleWidget *swidget = BB_SAMPLE_WIDGET (widget); if (swidget->last_drawing == NULL || widget->allocation.width != (gint) swidget->last_width || widget->allocation.height != (gint) swidget->last_height) { guint8 *rgb_data; guint width = widget->allocation.width; guint height = widget->allocation.height; guint depth = gdk_drawable_get_depth (widget->window); if (swidget->last_drawing) g_object_unref (swidget->last_drawing); rgb_data = g_malloc (3 * width * height); switch (swidget->mode) { case BB_SAMPLE_WIDGET_MODE_AMPLITUDE: render_amplitude_image (swidget, width, height, rgb_data); break; case BB_SAMPLE_WIDGET_MODE_FREQUENCY: render_fft_image (swidget, width, height, rgb_data); break; default: g_assert_not_reached (); } swidget->last_drawing = gdk_pixmap_new (widget->window, width, height, depth); gdk_draw_rgb_image (swidget->last_drawing, widget->style->fg_gc[0], 0, 0, width, height, GDK_RGB_DITHER_NORMAL, rgb_data, width * 3); g_free (rgb_data); swidget->last_width = width; swidget->last_height = height; } gdk_draw_drawable (widget->window, widget->style->fg_gc[0], swidget->last_drawing, expose->area.x, expose->area.y, expose->area.x, expose->area.y, expose->area.width, expose->area.height); if (swidget->has_time) { gint x = time_pixel (swidget); if (expose->area.x <= (int) x && (int)x < expose->area.x + expose->area.width) { if (swidget->time_line_gc == NULL) { GdkColor col; swidget->time_line_gc = gdk_gc_new (widget->window); col.red = 65535; col.green = 65535; col.blue = 0; gdk_gc_set_rgb_fg_color (swidget->time_line_gc, &col); } gdk_draw_line (widget->window, swidget->time_line_gc, x, expose->area.y, x, expose->area.y + expose->area.height); } } return TRUE; }
GdkPixmap* gdk_pixmap_create_from_data (GdkDrawable *drawable, const gchar *data, gint width, gint height, gint depth, const GdkColor *fg, const GdkColor *bg) { GdkPixmap *pixmap; gi_gc_ptr_t gc; g_return_val_if_fail (drawable == NULL || GDK_IS_DRAWABLE (drawable), NULL); g_return_val_if_fail (data != NULL, NULL); g_return_val_if_fail (drawable != NULL || depth > 0, NULL); g_return_val_if_fail (width > 0 && height > 0, NULL); GDK_NOTE (MISC, g_print ("gdk_pixmap_create_from_data: %dx%dx%d\n", width, height, depth)); pixmap = gdk_pixmap_new (drawable, width, height, depth); if (pixmap) { gi_window_id_t wid; gi_image_t* surface; gchar *dst; gint pitch; gint src_pitch; unsigned format ; depth = gdk_drawable_get_depth (pixmap); src_pitch = width * ((depth + 7) / 8); format = gi_get_choose_format(depth); //FIMXE wid = GDK_DRAWABLE_IMPL_GIX (GDK_PIXMAP_OBJECT (pixmap)->impl)->window_id; surface=gi_create_image_depth(width,height,format); dst = (gchar*)surface->rgba; pitch = surface->pitch; { gint i; for (i = 0; i < height; i++) { memcpy (dst, data, src_pitch); dst += pitch; data += src_pitch; } gc = gi_create_gc(wid,NULL); gi_draw_image(gc,surface,0,0); gi_destroy_gc(gc); gi_destroy_image(surface); } } return pixmap; }
static void desk_draw_bg(pager_priv *pg, desk *d1) { Pixmap xpix; GdkPixmap *gpix; GdkPixbuf *p1, *p2; gint width, height, depth; FbBg *bg = pg->fbbg; GtkWidget *widget = d1->da; ENTER; if (d1->no) { desk *d0 = d1->pg->desks[0]; if (d0->gpix && d0->xpix != None && d0->da->allocation.width == widget->allocation.width && d0->da->allocation.height == widget->allocation.height) { gdk_draw_drawable(d1->gpix, widget->style->fg_gc[GTK_WIDGET_STATE (widget)], d0->gpix,0, 0, 0, 0, widget->allocation.width, widget->allocation.height); d1->xpix = d0->xpix; DBG("copy gpix from d0 to d%d\n", d1->no); RET(); } } xpix = fb_bg_get_xrootpmap(bg); d1->xpix = None; width = widget->allocation.width; height = widget->allocation.height; DBG("w %d h %d\n", width, height); if (width < 3 || height < 3) RET(); // create new pix xpix = fb_bg_get_xrootpmap(bg); if (xpix == None) RET(); depth = gdk_drawable_get_depth(widget->window); gpix = fb_bg_get_xroot_pix_for_area(bg, 0, 0, gdk_screen_width(), gdk_screen_height(), depth); if (!gpix) { ERR("fb_bg_get_xroot_pix_for_area failed\n"); RET(); } p1 = gdk_pixbuf_get_from_drawable(NULL, gpix, NULL, 0, 0, 0, 0, gdk_screen_width(), gdk_screen_height()); if (!p1) { ERR("gdk_pixbuf_get_from_drawable failed\n"); goto err_gpix; } p2 = gdk_pixbuf_scale_simple(p1, width, height, //GDK_INTERP_NEAREST //GDK_INTERP_TILES //GDK_INTERP_BILINEAR GDK_INTERP_HYPER ); if (!p2) { ERR("gdk_pixbuf_scale_simple failed\n"); goto err_p1; } gdk_draw_pixbuf(d1->gpix, widget->style->fg_gc[GTK_WIDGET_STATE (widget)], p2, 0, 0, 0, 0, width, height, GDK_RGB_DITHER_NONE, 0, 0); d1->xpix = xpix; g_object_unref(p2); err_p1: g_object_unref(p1); err_gpix: g_object_unref(gpix); RET(); }
/* * attrib_list is currently unused. This must be set to NULL or empty * (first attribute of None). See GLX 1.3 spec. */ GdkGLPixmap * gdk_gl_pixmap_new (GdkGLConfig *glconfig, GdkPixmap *pixmap, const int *attrib_list) { GdkGLPixmap *glpixmap; GdkGLPixmapImplWin32 *impl; gint width, height; gint depth; GdkPixmap *pixmap_gl = NULL; HBITMAP hbitmap_gl; HDC hdc_gl = NULL; PIXELFORMATDESCRIPTOR pfd; int pixel_format; HBITMAP hbitmap_gdk; HDC hdc_gdk = NULL; GDK_GL_NOTE_FUNC (); g_return_val_if_fail (GDK_IS_GL_CONFIG_IMPL_WIN32 (glconfig), NULL); g_return_val_if_fail (GDK_IS_PIXMAP (pixmap), NULL); /* * Create offscreen rendering area. */ gdk_drawable_get_size (GDK_DRAWABLE (pixmap), &width, &height); depth = gdk_drawable_get_depth (GDK_DRAWABLE (pixmap)); pixmap_gl = gdk_pixmap_new (NULL, width, height, depth); if (pixmap_gl == NULL) goto FAIL; /* * Source (OpenGL) DIB */ hbitmap_gl = (HBITMAP) gdk_win32_drawable_get_handle (GDK_DRAWABLE (pixmap_gl)); /* Create a memory DC. */ hdc_gl = CreateCompatibleDC (NULL); if (hdc_gl == NULL) { g_warning ("cannot create a memory DC"); goto FAIL; } /* Select the bitmap. */ if (SelectObject (hdc_gl, hbitmap_gl) == NULL) { g_warning ("cannot select DIB"); goto FAIL; } /* * Choose pixel format. */ pfd = *(GDK_GL_CONFIG_PFD (glconfig)); /* Draw to bitmap */ pfd.dwFlags &= ~PFD_DRAW_TO_WINDOW; pfd.dwFlags |= PFD_DRAW_TO_BITMAP; /* Request pfd.cColorBits should exclude alpha bitplanes. */ pfd.cColorBits = pfd.cRedBits + pfd.cGreenBits + pfd.cBlueBits; GDK_GL_NOTE_FUNC_IMPL ("ChoosePixelFormat"); pixel_format = ChoosePixelFormat (hdc_gl, &pfd); if (pixel_format == 0) { g_warning ("cannot choose pixel format"); goto FAIL; } /* * Set pixel format. */ GDK_GL_NOTE_FUNC_IMPL ("SetPixelFormat"); if (!SetPixelFormat (hdc_gl, pixel_format, &pfd)) { g_warning ("cannot set pixel format"); goto FAIL; } DescribePixelFormat (hdc_gl, pixel_format, sizeof (pfd), &pfd); GDK_GL_NOTE (MISC, g_message (" -- impl->pixel_format = 0x%x", pixel_format)); GDK_GL_NOTE (MISC, _gdk_win32_gl_print_pfd (&pfd)); /* * Destination (GDK) DIB */ hbitmap_gdk = (HBITMAP) gdk_win32_drawable_get_handle (GDK_DRAWABLE (pixmap)); /* Create a memory DC. */ hdc_gdk = CreateCompatibleDC (hdc_gl); if (hdc_gdk == NULL) { g_warning ("cannot create a memory DC"); goto FAIL; } /* * Instantiate the GdkGLPixmapImplWin32 object. */ glpixmap = g_object_new (GDK_TYPE_GL_PIXMAP_IMPL_WIN32, NULL); impl = GDK_GL_PIXMAP_IMPL_WIN32 (glpixmap); glpixmap->drawable = GDK_DRAWABLE (pixmap); g_object_add_weak_pointer (G_OBJECT (glpixmap->drawable), (gpointer *) &(glpixmap->drawable)); impl->pixmap_gl = pixmap_gl; impl->width = width; impl->height = height; impl->pfd = pfd; impl->pixel_format = pixel_format; impl->glconfig = glconfig; g_object_ref (G_OBJECT (impl->glconfig)); impl->hdc_gl = hdc_gl; impl->hdc_gdk = hdc_gdk; impl->hbitmap_gdk = hbitmap_gdk; impl->is_destroyed = FALSE; return glpixmap; FAIL: if (hdc_gdk != NULL) DeleteDC (hdc_gdk); if (hdc_gl != NULL) DeleteDC (hdc_gl); if (pixmap_gl != NULL) g_object_unref (G_OBJECT (pixmap_gl)); return NULL; }
static VALUE rg_depth(VALUE self) { return INT2NUM(gdk_drawable_get_depth(_SELF(self))); }