自学教程：C++ GDK_DRAWABLE函数代码示例

gboolean expose_event_top_right(GtkWidget *widget,GdkEventExpose *event, gpointer user){	static GdkGC		*this_gc = NULL;	TimeLinePrivate		*priv;	gint				new_cursor_pos;	gint 				width;	gint				height;	priv = (TimeLinePrivate *)user;	if(priv->top_right_evb->window == NULL || priv->display_buffer_top_right == NULL){				return TRUE;	}	if (NULL == this_gc)	{		this_gc = gdk_gc_new(GDK_DRAWABLE(priv->top_right_evb->window));	}	width = ((get_current_slide_duration() +1)  * time_line_get_pixels_per_second());	height = (get_current_slide_num_layers() *priv->row_height)+10;	if(width<priv->main_table->allocation.width)		 width = priv->main_table->allocation.width;	if(height<priv->main_table->allocation.height)			 height = priv->main_table->allocation.height;	new_cursor_pos = round(time_line_get_cursor_position(priv->main_table->parent) * time_line_get_pixels_per_second());	time_line_internal_draw_cursor(priv->main_table->parent, new_cursor_pos);	gdk_draw_drawable(GDK_DRAWABLE(priv->top_right_evb->window), GDK_GC(this_gc),	GDK_PIXMAP(priv->display_buffer_top_right),0,0,0,0,width, priv->top_border_height);	return TRUE;}

/** * gdk_gl_window_new: * @glconfig: a #GdkGLConfig. * @window: the #GdkWindow to be used as the rendering area. * @attrib_list: (array) (allow-none): this must be set to NULL or empty (first attribute of None). * * Creates an on-screen rendering area. * attrib_list is currently unused. This must be set to NULL or empty * (first attribute of None). See GLX 1.3 spec. * * Return value: the new #GdkGLWindow. **/GdkGLWindow *gdk_gl_window_new (GdkGLConfig *glconfig, GdkWindow *window, const int *attrib_list){  GDK_GL_NOTE_FUNC ();  g_return_val_if_fail (GDK_IS_GL_CONFIG (glconfig), NULL);  g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);  /*   * Get X Window.   */  Window glxwindow = GDK_DRAWABLE_XID (GDK_DRAWABLE (window));  /*   * Instantiate the GdkGLWindowImplX11 object.   */  GdkGLWindow *glwindow = g_object_new (GDK_TYPE_GL_WINDOW, NULL);  glwindow->drawable = GDK_DRAWABLE (window);  g_object_add_weak_pointer (G_OBJECT (glwindow->drawable), (gpointer *) &(glwindow->drawable));  glwindow->glxwindow = glxwindow;  glwindow->glconfig = glconfig;  g_object_ref (G_OBJECT (glwindow->glconfig));  glwindow->is_destroyed = FALSE;  return glwindow;}

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;}

void WebBrowserObject::BrowserSnapshot(const char *fname){    int width, height;    char *c, *buf = 0;    GdkColormap *cmap = gdk_colormap_get_system();    gdk_drawable_get_size(GDK_DRAWABLE(mozilla->window), &width, &height);    GdkPixbuf *pix = gdk_pixbuf_get_from_drawable(0, GDK_DRAWABLE(mozilla->window), cmap, 0, 0, 0, 0, width, height);    if (pix) {       if (!fname) {           buf = strdup(location ? location : "lmboxweb");           buf = (char*)realloc(buf, strlen(buf) + 16);           fname = buf;           if ((c = strrchr(buf, '/'))) {               //fname = c + 1;           }           if ((c = strrchr(fname, '.'))) {               *c = 0;           }           strcat((char*)fname, ".png");       }       gdk_pixbuf_save (pix, fname, "png", NULL, NULL);       gdk_pixbuf_unref(pix);       printf("Webbrowser snapshot %s/n",fname);    }    gdk_colormap_unref(cmap);    lmbox_free(buf);}

static gbooleanexpose_callback (GtkWidget      *event_box,                 GdkEventButton *,                 TSignalData    *sigdata){    cairo_t *cr;    if (sigdata->event_box != NULL)        cr = gdk_cairo_create (GDK_DRAWABLE (sigdata->event_box->window));    else    {        cr = gdk_cairo_create (GDK_DRAWABLE (event_box->window));        sigdata->event_box = event_box;    }    if (sigdata->image != NULL)    {        GdkPixbuf *pxbf = gtk_image_get_pixbuf(GTK_IMAGE(sigdata->image));        gdk_cairo_set_source_pixbuf (cr, pxbf, 0,0);        cairo_paint (cr);        draw_grid(cr, sigdata->idata);    }    return TRUE;}

static voidgdk_wmspec_change_state (gboolean add,			 GdkWindow *window,			 GdkAtom state1,			 GdkAtom state2){  GdkDisplay *display =     gdk_screen_get_display (gdk_drawable_get_screen (GDK_DRAWABLE (window)));  XEvent xev;  #define _NET_WM_STATE_REMOVE        0    /* remove/unset property */#define _NET_WM_STATE_ADD           1    /* add/set property */#define _NET_WM_STATE_TOGGLE        2    /* toggle property  */      xev.xclient.type = ClientMessage;  xev.xclient.serial = 0;  xev.xclient.send_event = True;  xev.xclient.window = GDK_WINDOW_XID (window);  xev.xclient.message_type =     gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_STATE");  xev.xclient.format = 32;  xev.xclient.data.l[0] = add ? _NET_WM_STATE_ADD : _NET_WM_STATE_REMOVE;  xev.xclient.data.l[1] = gdk_x11_atom_to_xatom_for_display (display, state1);  xev.xclient.data.l[2] = gdk_x11_atom_to_xatom_for_display (display, state2);    XSendEvent (GDK_WINDOW_XDISPLAY (window),	      GDK_WINDOW_XWINDOW (gdk_screen_get_root_window (gdk_drawable_get_screen (GDK_DRAWABLE (window)))),	      False, SubstructureRedirectMask | SubstructureNotifyMask,	      &xev);}

gbooleanxfwmPixmapRenderGdkPixbuf (xfwmPixmap * pm, GdkPixbuf *pixbuf){    GdkPixbuf *src;    GdkPixmap *destw;    GdkVisual *gvisual;    GdkColormap *cmap;    gint width, height;    gint dest_x, dest_y;    g_return_val_if_fail (pm != NULL, FALSE);    g_return_val_if_fail (pm->pixmap != None, FALSE);    g_return_val_if_fail (pm->mask != None, FALSE);    destw = gdk_xid_table_lookup (pm->pixmap);    if (destw)    {        g_object_ref (G_OBJECT (destw));    }    else    {        destw = gdk_pixmap_foreign_new (pm->pixmap);    }    if (!destw)    {        g_warning ("Cannot get pixmap");        return FALSE;    }    gvisual = gdk_screen_get_system_visual (pm->screen_info->gscr);    cmap = gdk_x11_colormap_foreign_new (gvisual, pm->screen_info->cmap);    if (!cmap)    {        g_warning ("Cannot create colormap");        g_object_unref (destw);        return FALSE;    }    width = MIN (gdk_pixbuf_get_width (pixbuf), pm->width);    height = MIN (gdk_pixbuf_get_height (pixbuf), pm->height);    /* Add 1 for rounding */    dest_x = (pm->width - width + 1) / 2;    dest_y = (pm->height - height + 1) / 2;    src = gdk_pixbuf_get_from_drawable(NULL, GDK_DRAWABLE (destw), cmap,                                       dest_x, dest_y, 0, 0, width, height);    gdk_pixbuf_composite (pixbuf, src, 0, 0, width, height,                          0, 0, 1.0, 1.0, GDK_INTERP_NEAREST, 0xFF);    gdk_draw_pixbuf (GDK_DRAWABLE (destw), NULL, src, 0, 0, dest_x, dest_y,                     width, height, GDK_RGB_DITHER_NONE, 0, 0);    g_object_unref (cmap);    g_object_unref (src);    g_object_unref (destw);    return TRUE;}

void SetUpStatusBarStuff (GtkWidget* aWindow){	_String			   fName = baseDirectory & "GTKResources/striped.xpm";	statusBarLayout			 = pango_layout_new (screenPContext);	statusBarFontDesc		 = pango_font_description_new ();	stripedFill				 = gdk_pixmap_create_from_xpm (GDK_DRAWABLE(aWindow->window), NULL, NULL, fName.sData);	stripedFillGC			 = gdk_gc_new (GDK_DRAWABLE(aWindow->window));	if (stripedFill)	{		gdk_gc_set_fill (stripedFillGC,GDK_TILED);		gdk_gc_set_tile	(stripedFillGC,stripedFill);	}	else	{		printf ("Failed to load a status bar .xpm from %s/n", fName.sData);	}		gdk_gc_set_line_attributes		  (stripedFillGC, 1, GDK_LINE_SOLID, GDK_CAP_NOT_LAST, GDK_JOIN_MITER);	GdkColor saveFG = {0,0,0,0};	gdk_gc_set_foreground			  (stripedFillGC, &saveFG);	pango_font_description_set_family (statusBarFontDesc, statusBarFont.face.sData);	pango_font_description_set_style  (statusBarFontDesc, (statusBarFont.style & HY_FONT_ITALIC) ? PANGO_STYLE_ITALIC : PANGO_STYLE_NORMAL);	pango_font_description_set_weight (statusBarFontDesc, (statusBarFont.style & HY_FONT_BOLD) ? PANGO_WEIGHT_BOLD : PANGO_WEIGHT_NORMAL);	pango_font_description_set_size   (statusBarFontDesc, statusBarFont.size*PANGO_SCALE);	pango_layout_set_font_description (statusBarLayout, statusBarFontDesc ); // ref ?	pango_layout_set_width			  (statusBarLayout, -1);		redButtonIcon = (GdkPixbuf*)ProcureIconResource(4000);	yellowButtonIcon = (GdkPixbuf*)ProcureIconResource(4001);	greenButtonIcon = (GdkPixbuf*)ProcureIconResource(4002);	orangeButtonIcon = (GdkPixbuf*)ProcureIconResource(4003);	}

gboolean time_line_internal_draw_layer_name(TimeLinePrivate *priv, gint layer_number){	// Local variables	const GdkColor		colour_black = {0, 0, 0, 0 };	static GdkColormap	*colourmap = NULL;			// Colourmap used for drawing	static GdkGC		*display_buffer_gc = NULL;	static PangoContext *font_context = NULL;	static PangoFontDescription  *font_description = NULL;	static PangoLayout	*font_layout = NULL;	layer				*layer_data;	GList				*layer_pointer;				// Points to the layers in the selected slide	GString *message = NULL;	message  = g_string_new(NULL);	// Initialisation	if (NULL == colourmap)	{		colourmap = gdk_colormap_get_system();		gdk_drawable_set_colormap(GDK_DRAWABLE(priv->display_buffer_bot_left), GDK_COLORMAP(colourmap));	}	if (NULL == font_context)	{		font_context = gdk_pango_context_get();	}	if (NULL == font_layout)	{		font_layout = pango_layout_new(font_context);	}	if (NULL == display_buffer_gc)	{		display_buffer_gc = gdk_gc_new(GDK_DRAWABLE(priv->display_buffer_bot_left));	}	if (NULL == font_description)	{		font_description = pango_font_description_from_string("Sans , 15px");		pango_layout_set_font_description(font_layout, font_description);	}	// Retrieve the layer name string	layer_pointer = get_current_slide_layers_pointer();	layer_pointer = g_list_first(layer_pointer);	layer_data = g_list_nth_data(layer_pointer, layer_number);//	g_string_printf(message, "%d  %s ",layer_number,layer_data->name->str);	pango_layout_set_text(font_layout, layer_data->name->str, -1);	// Set a clip mask//	clip_region.x = 0;//	clip_region.y = (layer_number <= 0)?0:(layer_number * priv->row_height);//	clip_region.width = priv->left_border_width - 1;//	clip_region.height = priv->row_height * 2;//	gdk_gc_set_clip_rectangle(GDK_GC(display_buffer_gc), &clip_region);	// Draw the text string	gdk_gc_set_rgb_fg_color(GDK_GC(display_buffer_gc), &colour_black);	gdk_draw_layout(GDK_DRAWABLE(priv->display_buffer_bot_left), GDK_GC(display_buffer_gc), 5, (layer_number * priv->row_height)+1,font_layout);	return TRUE;}

static gbooleangdk_gl_pixmap_impl_x11_make_context_current (GdkGLDrawable *draw,                                             GdkGLDrawable *read,                                             GdkGLContext  *glcontext){  GdkGLConfig *glconfig;  GLXPixmap glxpixmap;  GLXContext glxcontext;  g_return_val_if_fail (GDK_IS_GL_PIXMAP_IMPL_X11 (draw), FALSE);  g_return_val_if_fail (GDK_IS_GL_CONTEXT_IMPL_X11 (glcontext), FALSE);  glconfig = GDK_GL_PIXMAP_IMPL_X11 (draw)->glconfig;  glxpixmap = GDK_GL_PIXMAP_IMPL_X11 (draw)->glxpixmap;  glxcontext = GDK_GL_CONTEXT_GLXCONTEXT (glcontext);  if (glxpixmap == None || glxcontext == NULL)    return FALSE;#ifdef GDKGLEXT_MULTIHEAD_SUPPORT  GDK_GL_NOTE (MISC,    g_message (" -- Pixmap: screen number = %d",      GDK_SCREEN_XNUMBER (gdk_drawable_get_screen (GDK_DRAWABLE (draw)))));#endif /* GDKGLEXT_MULTIHEAD_SUPPORT */  GDK_GL_NOTE (MISC,    g_message (" -- Pixmap: visual id = 0x%lx",      GDK_VISUAL_XVISUAL (gdk_drawable_get_visual (GDK_DRAWABLE (draw)))->visualid));  GDK_GL_NOTE_FUNC_IMPL ("glXMakeCurrent");  if (!glXMakeCurrent (GDK_GL_CONFIG_XDISPLAY (glconfig), glxpixmap, glxcontext))    {      g_warning ("glXMakeCurrent() failed");      _gdk_gl_context_set_gl_drawable (glcontext, NULL);      /* currently unused. */      /* _gdk_gl_context_set_gl_drawable_read (glcontext, NULL); */      return FALSE;    }  _gdk_gl_context_set_gl_drawable (glcontext, draw);  /* currently unused. */  /* _gdk_gl_context_set_gl_drawable_read (glcontext, read); */  if (_GDK_GL_CONFIG_AS_SINGLE_MODE (glconfig))    {      /* We do this because we are treating a double-buffered frame         buffer as a single-buffered frame buffer because the system         does not appear to export any suitable single-buffered         visuals (in which the following are necessary). */      glDrawBuffer (GL_FRONT);      glReadBuffer (GL_FRONT);    }  GDK_GL_NOTE (MISC, _gdk_gl_print_gl_info ());  return TRUE;}

GdkPixmap *make_pixmap(GtkScrollbox *self, gchar *value){        GdkWindow *rootwin;        PangoLayout *pl;        gint width, height, middle;        GdkPixmap *pixmap;        GtkRequisition widgsize = {0, };         GtkWidget *widget = (GtkWidget *)self;        	/* If we can't draw yet, don't do anything to avoid screwing things */	if (!GDK_IS_GC(widget->style->bg_gc[0]))		return NULL;        rootwin = gtk_widget_get_root_window(widget);        pl = gtk_widget_create_pango_layout(widget, NULL);        pango_layout_set_markup(pl, value, -1);        pango_layout_get_pixel_size(pl, &width, &height);        pixmap = gdk_pixmap_new(GDK_DRAWABLE(rootwin), width, height, -1);        gdk_draw_rectangle(GDK_DRAWABLE(pixmap),                         widget->style->bg_gc[0],                        TRUE, 0, 0, width, height);        gdk_draw_layout(GDK_DRAWABLE(pixmap), widget->style->fg_gc[0], 0, 0, pl);        g_object_unref(pl);        gtk_widget_size_request(widget, &widgsize);        if (width <= widgsize.width)                width = widgsize.width;        if (height <= widgsize.height)                height = widgsize.height;        else                self->draw_maxoffset = -height;        if (width != widgsize.width || height != widgsize.height)                gtk_widget_set_size_request(widget, width, height);        middle = width / 2;        if (self->draw_maxmiddle < middle)                self->draw_maxmiddle = middle;        return pixmap;}

void debug_save_widget(GtkWidget *widget){	GdkPixmap *pixmap;	GdkPixbuf *pixbuf;	gint w, h;	pixmap = gtk_widget_get_snapshot(widget, NULL);	gdk_drawable_get_size(GDK_DRAWABLE(pixmap), &w, &h);	pixbuf = gdk_pixbuf_get_from_drawable(NULL, GDK_DRAWABLE(pixmap),	    NULL, 0, 0, 0, 0, w, h);	debug_save_pixbuf(pixbuf);	gdk_pixmap_unref(pixmap);	g_object_unref(pixbuf);}

static gbooleangtk_experiment_transcript_expose(GtkWidget *widget, GdkEventExpose *event){	GtkExperimentTranscript *trans = GTK_EXPERIMENT_TRANSCRIPT(widget);	gdk_draw_drawable(GDK_DRAWABLE(gtk_widget_get_window(widget)),			  widget->style->fg_gc[gtk_widget_get_state(widget)],			  GDK_DRAWABLE(trans->priv->layer_text),			  event->area.x, event->area.y,			  event->area.x, event->area.y,			  event->area.width, event->area.height);	return FALSE;}

void UI_buildui(IBusHandwriteEngine * engine){	GdkPixmap * pxmp;	GdkGC * gc;	GdkColor black, white;	GdkColormap* colormap = gdk_colormap_get_system();	gdk_color_black(colormap, &black);	gdk_color_white(colormap, &white);	g_object_unref(colormap);	int R = 5;	if (!engine->drawpanel)	//建立绘图窗口, 建立空点	{		engine->drawpanel = gtk_window_new(GTK_WINDOW_POPUP);		gtk_window_move((GtkWindow*) engine->drawpanel, 500, 550);		gtk_widget_add_events(GTK_WIDGET(engine->drawpanel),				GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK						| GDK_BUTTON_PRESS_MASK | GDK_EXPOSURE_MASK);		g_signal_connect_after(G_OBJECT(engine->drawpanel),"motion_notify_event",G_CALLBACK(on_mouse_move),engine);		g_signal_connect(G_OBJECT(engine->drawpanel),"expose-event",G_CALLBACK(paint_ui),engine);		g_signal_connect(G_OBJECT(engine->drawpanel),"button-release-event",G_CALLBACK(on_button),engine);		g_signal_connect(G_OBJECT(engine->drawpanel),"button-press-event",G_CALLBACK(on_button),engine);		gtk_window_resize(GTK_WINDOW(engine->drawpanel), 200, 250);		gtk_widget_show(engine->drawpanel);		pxmp = gdk_pixmap_new(NULL, 200, 250, 1);		gc = gdk_gc_new(GDK_DRAWABLE(pxmp));		gdk_gc_set_foreground(gc, &black);		gdk_draw_rectangle(GDK_DRAWABLE(pxmp), gc, 1, 0, 0, 200, 250);		gdk_gc_set_foreground(gc, &white);		gdk_draw_arc(GDK_DRAWABLE(pxmp), gc, 1, 0, 0, R*2, R*2, 0, 360 * 64);		gdk_draw_arc(GDK_DRAWABLE(pxmp), gc, 1, 200 - R*2, 0, R*2, R*2, 0, 360				* 64);		gdk_draw_arc(GDK_DRAWABLE(pxmp), gc, 1, 200 - R*2, 250 - R*2, R*2, R*2, 0,				360 * 64);		gdk_draw_arc(GDK_DRAWABLE(pxmp), gc, 1, 0, 250 - R*2, R*2, R*2, 0, 360				* 64);		gdk_draw_rectangle(GDK_DRAWABLE(pxmp), gc, 1, 0, R, 200, 250 - R*2);		gdk_draw_rectangle(GDK_DRAWABLE(pxmp), gc, 1, R, 0, 200 - R*2, 250);		gdk_window_shape_combine_mask(engine->drawpanel->window, pxmp, 0, 0);		g_object_unref(gc);		g_object_unref(pxmp);		gtk_window_set_opacity(GTK_WINDOW(engine->drawpanel), 0.62);		//	engine->GdkPoints = NULL;	}	//	gtk_widget_show_all(engine->drawpanel);}

void	_HYSequencePane::_Paint (Ptr p){	_HYRect* 	destR = (_HYRect*)p;		_HYRect 	srcRect,				destRect = *destR;					//printf ("Sequence Paint Called %d %d %d %d/n", destR->left, destR->top, destR->right, destR->bottom);		if (HasHScroll())		destRect.bottom-= HY_SCROLLER_WIDTH;			if (HasVScroll())		destRect.right -= HY_SCROLLER_WIDTH;			//destRect.left 		= destR->left;	//destRect.top 		= destR->top;	_HYRect srcR 		= _VisibleContents (p);		gdk_draw_drawable (GDK_DRAWABLE(parentWindow->window), theContext, thePane, 0, 0, 						parentWindow->allocation.x+destRect.left, parentWindow->allocation.y+destRect.top, destRect.Width(), destRect.Height()); 	long		saveBorder = settings.width & HY_COMPONENT_BORDER;	settings.width -= saveBorder;	_HYPlatformComponent::_Paint(p);	settings.width += saveBorder;}

static voidgdk_drawable_impl_x11_finalize (GObject *object){  gdk_drawable_set_colormap (GDK_DRAWABLE (object), NULL);  G_OBJECT_CLASS (_gdk_drawable_impl_x11_parent_class)->finalize (object);}

static VALUErg_s_from_drawable(int argc, VALUE *argv, G_GNUC_UNUSED VALUE self){    VALUE cmap, src, src_x, src_y, width, height, dest, dest_x, dest_y;    GdkPixbuf* buf;    rb_scan_args(argc, argv, "63", &cmap, &src, &src_x, &src_y, &width, &height,                  &dest, &dest_x, &dest_y);    buf = gdk_pixbuf_get_from_drawable(GDK_PIXBUF(RVAL2GOBJ(dest)),                                       GDK_DRAWABLE(RVAL2GOBJ(src)),                                       GDK_COLORMAP(RVAL2GOBJ(cmap)),                                       NUM2INT(src_x), NUM2INT(src_y),                                       NIL_P(dest_x) ? 0 : NUM2INT(dest_x),                                       NIL_P(dest_y) ? 0 : NUM2INT(dest_y),                                       NUM2INT(width), NUM2INT(height));    if (NIL_P(dest)) {        if (buf) {            return GOBJ2RVALU(buf);        } else {            return Qnil;        }    } else {        return dest;    }}

/* Copy selection */void copy(GtkWidget *widget, gpointer data){//widget and data are useless  if (!selection_is_on)    show_error_message("No hay nada seleccionado para copiar");    save_paste_positions();  clipboard_pixbuf = gdk_pixbuf_get_from_drawable(NULL,GDK_DRAWABLE(canvas->window),gdk_colormap_get_system(),selection_x1,selection_y1,0,0,selection_x2-selection_x1,selection_y2-selection_y1);}

static gbooleanpiano_keyboard_expose(GtkWidget *widget, GdkEventExpose *event){	int i;	PianoKeyboard *pk = PIANO_KEYBOARD(widget);	cairo_t* cr = gdk_cairo_create (GDK_DRAWABLE (GTK_WIDGET(pk)->window));	gdk_cairo_region (cr, event->region);	cairo_clip (cr);	for (i = 0; i < NNOTES; i++) {		GdkRectangle r;		r.x = pk->notes[i].x;		r.y = 0;		r.width = pk->notes[i].w;		r.height = pk->notes[i].h;		switch (gdk_region_rect_in (event->region, &r)) {		case GDK_OVERLAP_RECTANGLE_PART:		case GDK_OVERLAP_RECTANGLE_IN:			draw_note (pk, cr, i);			break;		default:			break;		}	}	cairo_destroy (cr);	return TRUE;}

static voidplayer_av_set_video_destination (Player *self, GtkWidget *dest){    PlayerAVPrivate *priv = PLAYER_AV (self)->priv;    if (priv->video_dest) {        gdk_window_invalidate_rect (priv->video_dest->window, NULL, TRUE);    }    priv->video_dest = dest;    if (dest) {        player_av_change_gdk_window (PLAYER_AV (self), dest->window);    } else {        if (priv->fullscreen) {            player_av_change_gdk_window (PLAYER_AV (self), priv->fs_da->window);            priv->video_dest = priv->fs_da;        } else {            player_av_change_gdk_window (PLAYER_AV (self), priv->em_da->window);            priv->video_dest = priv->em_da;        }    }    g_signal_connect (priv->video_dest, "size-allocate", G_CALLBACK (on_alloc_event), self);    gdk_drawable_get_size (GDK_DRAWABLE (priv->video_dest->window),        &priv->win_width, &priv->win_height);}

/* Redraw the screen from the backing pixmap */static gboolean expose_event (GtkWidget      *widget,                              GdkEventExpose *event){	static GdkImage *image = NULL;	GdkCursor *cursor;	GdkPixbuf *pixbuf;	if (framebuffer_allocated == FALSE) {		rfbClientSetClientData (cl, gtk_init, widget);		image = gdk_drawable_get_image (widget->window, 0, 0,		                                widget->allocation.width,		                                widget->allocation.height);		cl->frameBuffer= image->mem;		cl->width  = widget->allocation.width;		cl->height = widget->allocation.height;		cl->format.bitsPerPixel = image->bits_per_pixel;		cl->format.redShift     = image->visual->red_shift;		cl->format.greenShift   = image->visual->green_shift;		cl->format.blueShift    = image->visual->blue_shift;		cl->format.redMax   = (1 << image->visual->red_prec) - 1;		cl->format.greenMax = (1 << image->visual->green_prec) - 1;		cl->format.blueMax  = (1 << image->visual->blue_prec) - 1;#ifdef LIBVNCSERVER_CONFIG_LIBVA		/* Allow libvncclient to use a more efficient way		 * of putting the framebuffer on the screen when		 * using the H.264 format.		 */		cl->outputWindow = GDK_WINDOW_XID(widget->window);#endif		SetFormatAndEncodings (cl);		framebuffer_allocated = TRUE;		/* Also disable local cursor */                pixbuf = gdk_pixbuf_new_from_xpm_data(dot_cursor_xpm);	        cursor = gdk_cursor_new_from_pixbuf(gdk_display_get_default(), pixbuf, dot_cursor_x_hot, dot_cursor_y_hot);		g_object_unref(pixbuf);			gdk_window_set_cursor (gtk_widget_get_window(GTK_WIDGET(window)), cursor);		gdk_cursor_unref(cursor);	}#ifndef LIBVNCSERVER_CONFIG_LIBVA	gdk_draw_image (GDK_DRAWABLE (widget->window),	                widget->style->fg_gc[gtk_widget_get_state(widget)],	                image,	                event->area.x, event->area.y,	                event->area.x, event->area.y,	                event->area.width, event->area.height);#endif	return FALSE;}

static gboolean pidgin_whiteboard_configure_event(GtkWidget *widget, GdkEventConfigure *event, gpointer data){	PidginWhiteboard *gtkwb = (PidginWhiteboard*)data;	GdkPixmap *pixmap = gtkwb->pixmap;	cairo_t *cr;	if (pixmap) {		cr = g_object_get_data(G_OBJECT(pixmap), "cairo-context");		if (cr)			cairo_destroy(cr);		g_object_unref(pixmap);	}	pixmap = gdk_pixmap_new(widget->window,							widget->allocation.width,							widget->allocation.height,							-1);	gtkwb->pixmap = pixmap;	cr = gdk_cairo_create(GDK_DRAWABLE(pixmap));	g_object_set_data(G_OBJECT(pixmap), "cairo-context", cr);	gdk_cairo_set_source_color(cr, &widget->style->white);	cairo_rectangle(cr,	                0, 0,	                widget->allocation.width, widget->allocation.height);	cairo_fill(cr);	return TRUE;}

static VALUErg_set_drawable(VALUE self, VALUE drawable){    gdk_pango_renderer_set_drawable(_SELF(self),                                     GDK_DRAWABLE(RVAL2GOBJ(drawable)));    return self;}

gbooleantotem_ratio_fits_screen (GdkWindow * video_window, int video_width,    int video_height, gfloat ratio){  GdkRectangle fullscreen_rect;  int new_w, new_h;  GdkScreen *screen;  if (video_width <= 0 || video_height <= 0)    return TRUE;  new_w = video_width * ratio;  new_h = video_height * ratio;  screen = gdk_drawable_get_screen (GDK_DRAWABLE (video_window));  gdk_screen_get_monitor_geometry (screen,      gdk_screen_get_monitor_at_window      (screen, video_window), &fullscreen_rect);  if (new_w > (fullscreen_rect.width - 128) ||      new_h > (fullscreen_rect.height - 128)) {    return FALSE;  }  return TRUE;}

static int ControlWindow (vout_window_t *p_wnd, int query, va_list args){    intf_thread_t *p_intf = (intf_thread_t *)p_wnd->sys;    switch( query )    {    case VOUT_WINDOW_SET_SIZE:    {        int i_width  = (int)va_arg( args, int );        int i_height = (int)va_arg( args, int );        int i_current_w, i_current_h;        gdk_drawable_get_size( GDK_DRAWABLE( p_intf->p_sys->p_video_window ),                               &i_current_w, &i_current_h );        if( i_width != i_current_w || i_height != i_current_h )            return VLC_EGENERIC;        return VLC_SUCCESS;    }    case VOUT_WINDOW_SET_FULLSCREEN:    {        bool b_fs = va_arg( args, int );        p_intf->p_sys->b_fullscreen = b_fs;        g_idle_add( fullscreen_cb, p_intf );        return VLC_SUCCESS;    }    default:        return VLC_EGENERIC;    }}

void start_recording(GtkWidget *widget, gpointer data) {    GdkNativeWindow native;    GdkDisplay *display;    GdkRectangle rect;    if(is_recording)        return;    screen = gtk_widget_get_screen(widget);    if (screen == NULL) {        screen = gdk_screen_get_default ();    }    native = select_window(screen);    display = gdk_screen_get_display (screen);    window = gdk_window_foreign_new_for_display (display, native);    gdk_drawable_get_size (GDK_DRAWABLE (window), &rect.width, &rect.height);    /* creating flv und screenVideo instances */    flv = newFLVStream(FLVVERSION_1, FLVFLAG_VIDEO);    video = newScreenVideo(rect.width, rect.height, 64);    printf("video width: %i, height: %i/n", rect.width, rect.height);    /* capture timer */    g_timeout_add ( 1000 / FRAMERATE,  next_capture, NULL);    is_recording = 1;}

static voidfill_pixel_rect(DiaRenderer *object,		int x, int y,		int width, int height,		Color *color){  DiaGdkRenderer *renderer = DIA_GDK_RENDERER (object);  GdkGC *gc = renderer->gc;  GdkColor gdkcolor;  int target_width, target_height;      gdk_drawable_get_size (GDK_DRAWABLE (renderer->pixmap), &target_width, &target_height);      if (x + width < 0 || y + height < 0 || x > target_width || y > target_height)    return; /* clip early rather than failing in Gdk */  color_convert(color, &gdkcolor);  gdk_gc_set_foreground(gc, &gdkcolor);  /* reset stippling (alpha emulation) */  gdk_gc_set_fill(gc, GDK_SOLID);  renderer->current_alpha = 1.0;  gdk_draw_rectangle (renderer->pixmap, gc, TRUE,		      x, y,  width, height);}

static voiddraw_pixel_line(DiaRenderer *object,		int x1, int y1,		int x2, int y2,		Color *color){  DiaGdkRenderer *renderer = DIA_GDK_RENDERER (object);  GdkGC *gc = renderer->gc;  GdkColor gdkcolor;  int target_width, target_height;      dia_gdk_renderer_set_dashes(renderer, x1+y1);  gdk_drawable_get_size (GDK_DRAWABLE (renderer->pixmap), &target_width, &target_height);  if (   (x1 < 0 && x2 < 0)      || (y1 < 0 && y2 < 0)      || (x1 > target_width && x2 > target_width)       || (y1 > target_height && y2 > target_height))    return; /* clip early rather than failing in Gdk */    color_convert(color, &gdkcolor);  gdk_gc_set_foreground(gc, &gdkcolor);  /* reset stippling (alpha emulation) */  gdk_gc_set_fill(gc, GDK_SOLID);  renderer->current_alpha = 1.0;    gdk_draw_line(renderer->pixmap, gc, x1, y1, x2, y2);}

static gbooleanrender_contribution_topdown(GtkExperimentTranscript *trans,			    ExperimentReaderContrib *contrib,			    gint64 current_time, gint64 current_time_px,			    gint *last_contrib_y){	GtkWidget *widget = GTK_WIDGET(trans);	gint old_last_contrib_y = *last_contrib_y;	int logical_height;	*last_contrib_y = current_time_px - TIME_TO_PX(contrib->start_time);	if (!configure_text_layout(trans, contrib, current_time,				   *last_contrib_y, old_last_contrib_y,				   &logical_height))		return TRUE;	if (*last_contrib_y - logical_height > widget->allocation.height)		return FALSE;	gdk_draw_layout(GDK_DRAWABLE(trans->priv->layer_text),			widget->style->text_gc[gtk_widget_get_state(widget)],			0, *last_contrib_y - logical_height,			trans->priv->layer_text_layout);	return *last_contrib_y < widget->allocation.height;}

GdkCursor *create_cursor(GdkWindow *window,	      const guint8 *data,	      int hot_x, int hot_y){  GdkPixbuf *pixbuf;  GdkCursor *cursor;  GdkDisplay *display;  g_return_val_if_fail(window != NULL, NULL);#if GTK_CHECK_VERSION (2,24,0)  display = gdk_window_get_display (window);#else  display = gdk_drawable_get_display (GDK_DRAWABLE (window));#endif  pixbuf = gdk_pixbuf_new_from_inline(-1, data, FALSE, NULL);  cursor = gdk_cursor_new_from_pixbuf (display, pixbuf, hot_x,hot_y);  g_assert(cursor != NULL);  g_object_unref(pixbuf);  return cursor;}