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

static gbooleanempathy_video_widget_expose_event (GtkWidget *widget, GdkEventExpose *event){  EmpathyVideoWidget *self = EMPATHY_VIDEO_WIDGET (widget);  EmpathyVideoWidgetPriv *priv = GET_PRIV (self);  if (event != NULL && event->count > 0)    return TRUE;  if (priv->overlay == NULL)    return TRUE;  gst_x_overlay_set_xwindow_id (GST_X_OVERLAY (priv->overlay),    GDK_WINDOW_XID (widget->window));  gst_x_overlay_expose (GST_X_OVERLAY (priv->overlay));  return TRUE;}

voidgdk_x11_window_force_focus (GdkWindow *window,                            guint32    timestamp){    GdkDisplay *display;    g_return_if_fail (GDK_IS_WINDOW (window));    display = GDK_WINDOW_DISPLAY (window);    if (GTK_CHECK_VERSION(3,0,0) && !GDK_IS_X11_DISPLAY (display))        return;    if (gdk_x11_screen_supports_net_wm_hint (gdk_window_get_screen (window),                        gdk_atom_intern_static_string ("_NET_ACTIVE_WINDOW")))    {        if (!timestamp)        {            GTimeVal t;            g_get_current_time (&t);            timestamp = t.tv_sec;        }        XClientMessageEvent xclient;        memset (&xclient, 0, sizeof (xclient));        xclient.type = ClientMessage;        xclient.window = GDK_WINDOW_XID (window);        xclient.message_type = gdk_x11_get_xatom_by_name_for_display (display,                                                                    "_NET_ACTIVE_WINDOW");        xclient.format = 32;        xclient.data.l[0] = 2; /* requestor type; we're a tool */        xclient.data.l[1] = timestamp;        xclient.data.l[2] = None; /* currently active window */        xclient.data.l[3] = 0;        xclient.data.l[4] = 0;        XSendEvent (GDK_DISPLAY_XDISPLAY (display), GDK_WINDOW_XROOTWIN (window), False,                    SubstructureRedirectMask | SubstructureNotifyMask,                    (XEvent *)&xclient);    }}

//-----------------------------------------// based on code contributed by pclouds//-----------------------------------------static GdkFilterReturngtk_im_context_vn_event_filter (GdkXEvent *xevent,				GdkEvent *event,				gpointer data){  XPropertyEvent *ev = (XPropertyEvent*)xevent;  long v;  GdkWindow *gdkroot = gdk_get_default_root_window();  Window root = GDK_WINDOW_XID(gdkroot);  if (!ev ||      ev->type != PropertyNotify ||      ev->window != root)    return GDK_FILTER_CONTINUE;      if (ev->atom == AIMCharset) {    v = UkGetPropValue(ev->atom, VKC_UTF8);    GlobalOpt.charset = SyncToUnikeyCharset(v);    UnikeySetOutputCharset(GlobalOpt.charset);    /*    if (UkMacroLoaded)      UkUpdateMacroTable(GlobalOpt.charset);    */    return GDK_FILTER_REMOVE;  }  else if (ev->atom == AIMMethod) {    fixSyncToUnikeyMethod();    if (GlobalOpt.enabled)      UnikeySetInputMethod(GlobalOpt.inputMethod);    return GDK_FILTER_REMOVE;  }  else if (ev->atom == AIMUsing) {    //dont' need this    return GDK_FILTER_REMOVE;  }  else if (ev->atom == AGUIVisible) {    UkGUIVisible = UkGetPropValue(AGUIVisible, 0);  }  return GDK_FILTER_CONTINUE;}

static voidungrab_mmkey (int key_code,	      GdkWindow *root){	Display *display;	gdk_error_trap_push ();	display = GDK_DISPLAY_XDISPLAY (gdk_display_get_default ());	XUngrabKey (display, key_code, 0, GDK_WINDOW_XID (root));	XUngrabKey (display, key_code, Mod2Mask, GDK_WINDOW_XID (root));	XUngrabKey (display, key_code, Mod5Mask, GDK_WINDOW_XID (root));	XUngrabKey (display, key_code, LockMask, GDK_WINDOW_XID (root));	XUngrabKey (display, key_code, Mod2Mask | Mod5Mask, GDK_WINDOW_XID (root));	XUngrabKey (display, key_code, Mod2Mask | LockMask, GDK_WINDOW_XID (root));	XUngrabKey (display, key_code, Mod5Mask | LockMask, GDK_WINDOW_XID (root));	XUngrabKey (display, key_code, Mod2Mask | Mod5Mask | LockMask, GDK_WINDOW_XID (root));	gdk_flush ();        if (gdk_error_trap_pop ()) {		rb_debug ("Error grabbing key");	}}

//================================================================  int GLB_DrawInit (void *widget) {//================================================================/// GLB_DrawInit          start OpenGL-commandblock  GdkWindow     *window;  if(!GLB_x_id) {    window = gtk_widget_get_window (widget);    GLB_x_id = GDK_WINDOW_XID(window);                // causes expose!      printf("  GLB_x_id=%d/n",GLB_x_id);  }  // GLB_x_context = glXCreateContext (GLB_display, xvisual, NULL, TRUE);  glXMakeCurrent (GLB_display, GLB_x_id, GLB_x_context);  return 0;}

static void uninstall_keygrab(void){        GdkDisplay *display = gdk_display_get_default();        int i;        for (i = 0; i < gdk_display_get_n_screens (display); i++) {                GdkScreen *screen;                GdkWindow *root;                screen = gdk_display_get_screen (display, i);                if (!screen) {                        continue;                }                root = gdk_screen_get_root_window (screen);                XUngrabKey(GDK_DISPLAY(),                           AnyKey,                           AnyModifier,                           GDK_WINDOW_XID(root));        }}

void GTKVideo::realize_cb(GtkWidget *widget, void *user_data) {  GTKVideo *context = static_cast<GTKVideo *>(user_data);  GdkWindow *window = gtk_widget_get_window(widget);  if (!gdk_window_ensure_native(window))    g_debug("Couldn't create native window needed for GstXOverlay!");  gdk_threads_enter();  gdk_display_sync(context->display_);  // gdk_error_trap_pop ();  /* Retrieve window handler from GDK */#if defined(GDK_WINDOWING_WIN32)  context->window_handle_ = reinterpret_cast<guintptr>(GDK_WINDOW_HWND(window));#elif defined(GDK_WINDOWING_QUARTZ)  context->window_handle_ = gdk_quartz_window_get_nsview(window);#elif defined(GDK_WINDOWING_X11)  context->window_handle_ = GDK_WINDOW_XID(window);#endif  gdk_threads_leave();  std::unique_lock<std::mutex> lock(context->wait_window_mutex_);  context->wait_window_cond_.notify_all();}

voidgtku_gl_drawing_area_swap_buffers (GtkuGLDrawingArea * self){    GtkWidget * widget = GTK_WIDGET (self);    GtkuGLDrawingAreaPrivate * priv = GTKU_GL_DRAWING_AREA_GET_PRIVATE (self);#ifdef USE_VBLANK    if (priv->vblank_watch) {        /* If we are syncing to vblank, we just set a flag that a         * swap is desired. */        priv->swap_requested = 1;        return;    }#endif    /* If we can't monitor vblank, we swap immediately. */    if (!GTK_WIDGET_REALIZED (widget) || !priv->dpy)        return;    glXSwapBuffers (priv->dpy, GDK_WINDOW_XID (widget->window));}

Ogre::String getWindowHandleString(GtkWidget *widget){    Ogre::String handle;    // GTK_WIDGET_SET_FLAGS(widget, GTK_REALIZED);    gtk_widget_realize(widget);    GdkWindow *parent = gtk_widget_get_parent_window(widget);//    gdk_window_show(parent);#if defined(__WIN32__) || defined(_WIN32)    handle = Ogre::StringConverter::toString((unsigned long) GDK_WINDOW_HWND(parent));#else// #elif defined(__WXGTK__)    GdkDisplay* display = gdk_drawable_get_display(GDK_DRAWABLE(parent));    Display *xdisplay = GDK_DISPLAY_XDISPLAY(display);    XSync(xdisplay, false);    GdkScreen* screen = gdk_drawable_get_screen(GDK_DRAWABLE(parent));    Screen *xscreen = GDK_SCREEN_XSCREEN(screen);    int screen_number = XScreenNumberOfScreen(xscreen);//    XID xid_parent = GDK_WINDOW_XWINDOW(parent);    // "parentWindowHandle"//    handle =//        Ogre::StringConverter::toString(reinterpret_cast<unsigned long>(xdisplay)) + ":" +//        Ogre::StringConverter::toString(static_cast<unsigned int>(screen_number)) + ":" +//        Ogre::StringConverter::toString(static_cast<unsigned long>(xid_parent));    handle = Ogre::StringConverter::toString(static_cast<unsigned long>(GDK_WINDOW_XID(parent)));#endif    // dunno what MacOS needs - you tell me    return handle;}

/* The plug window should completely occupy the area of the child, so we won't * get a draw event. But in case we do (the plug unmaps itself, say), this * draw handler draws with real or fake transparency. */static gbooleanna_tray_child_draw (GtkWidget *widget,                    cairo_t   *cr){  NaTrayChild *child = NA_TRAY_CHILD (widget);  if (na_tray_child_has_alpha (child))    {      /* Clear to transparent */      cairo_set_source_rgba (cr, 0, 0, 0, 0);      cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);      cairo_paint (cr);    }  else if (child->parent_relative_bg)    {      GdkWindow *window;      cairo_surface_t *target;      GdkRectangle clip_rect;      window = gtk_widget_get_window (widget);      target = cairo_get_group_target (cr);      gdk_cairo_get_clip_rectangle (cr, &clip_rect);      /* Clear to parent-relative pixmap       * We need to use direct X access here because GDK doesn't know about       * the parent relative pixmap. */      cairo_surface_flush (target);      XClearArea (GDK_WINDOW_XDISPLAY (window),                  GDK_WINDOW_XID (window),                  clip_rect.x, clip_rect.y,                  clip_rect.width, clip_rect.height,                  False);      cairo_surface_mark_dirty_rectangle (target,                                          clip_rect.x, clip_rect.y,                                          clip_rect.width, clip_rect.height);    }  return FALSE;}

static gboolean on_draw(GtkWidget* w, cairo_t* cr, gpointer data){    g_debug("%s", __func__);    if (ctx == 0 || glxwin == 0 || glx_pm == 0) return TRUE;    glXMakeContextCurrent(display, glxwin, glxwin, ctx);    glViewport (0, 0, g_width, g_height);    GdkWindow* gdkwin = gtk_widget_get_window(w);    XWindowAttributes  gwa;    XGetWindowAttributes(display, GDK_WINDOW_XID(gdkwin), &gwa);    glViewport(0, 0, gwa.width, gwa.height);    glClearColor(1.0, 1.0, 1.0, 1.0);    glClear(GL_COLOR_BUFFER_BIT);    glEnable(GL_TEXTURE_2D);    GLuint texture;    glGenTextures(1, &texture);    glBindTexture(GL_TEXTURE_2D, texture);    glXBindTexImageEXT(display, glx_pm, GLX_FRONT_EXT, NULL);    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);    glBegin(GL_QUADS);        glTexCoord2f(0.0, 0.0); glVertex3f(-1.0,  1.0, 0.0);        glTexCoord2f(1.0, 0.0); glVertex3f( 1.0,  1.0, 0.0);        glTexCoord2f(1.0, 1.0); glVertex3f( 1.0, -1.0, 0.0);        glTexCoord2f(0.0, 1.0); glVertex3f(-1.0, -1.0, 0.0);    glEnd();     if (dbuffered) glXSwapBuffers(display, glxwin);    else glFlush();     /*glXMakeCurrent(display, 0, 0);*/    return TRUE;}

/** * unique_backend_get_workspace: * @backend: a #UniqueBackend * * Retrieves the current workspace. * * Return value: a workspace number */guintunique_backend_get_workspace (UniqueBackend *backend){  GdkDisplay *display;  GdkWindow *root_win;#ifdef GDK_WINDOWING_X11  Atom _net_current_desktop, type;  int format;  unsigned long n_items, bytes_after;  unsigned char *data_return = 0;#endif  g_return_val_if_fail (UNIQUE_IS_BACKEND (backend), 0);  if (backend->workspace != -1)    return backend->workspace;  display = gdk_screen_get_display (backend->screen);  root_win = gdk_screen_get_root_window (backend->screen);#ifdef GDK_WINDOWING_X11  _net_current_desktop =    gdk_x11_get_xatom_by_name_for_display (display, "_NET_CURRENT_DESKTOP");  XGetWindowProperty (GDK_DISPLAY_XDISPLAY (display),                      GDK_WINDOW_XID (root_win),                      _net_current_desktop,                      0, G_MAXLONG,                      False, XA_CARDINAL,                      &type, &format, &n_items, &bytes_after,                      &data_return);  if (type == XA_CARDINAL && format == 32 && n_items > 0)    {      backend->workspace = (guint) data_return[0];      XFree (data_return);    }#endif  return backend->workspace;}

/** * gedit_utils_get_window_workspace: Get the workspace the window is on * * This function gets the workspace that the #GtkWindow is visible on, * it returns GEDIT_ALL_WORKSPACES if the window is sticky, or if * the window manager doesn support this function */guintgedit_utils_get_window_workspace (GtkWindow *gtkwindow){#ifdef GDK_WINDOWING_X11	GdkWindow *window;	GdkDisplay *display;	Atom type;	gint format;	gulong nitems;	gulong bytes_after;	guint *workspace;	gint err, result;	guint ret = GEDIT_ALL_WORKSPACES;	g_return_val_if_fail (GTK_IS_WINDOW (gtkwindow), 0);	g_return_val_if_fail (GTK_WIDGET_REALIZED (GTK_WIDGET (gtkwindow)), 0);	window = gtk_widget_get_window (GTK_WIDGET (gtkwindow));	display = gdk_drawable_get_display (window);	gdk_error_trap_push ();	result = XGetWindowProperty (GDK_DISPLAY_XDISPLAY (display), GDK_WINDOW_XID (window),				     gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_DESKTOP"),				     0, G_MAXLONG, False, XA_CARDINAL, &type, &format, &nitems,				     &bytes_after, (gpointer) &workspace);	err = gdk_error_trap_pop ();	if (err != Success || result != Success)		return ret;	if (type == XA_CARDINAL && format == 32 && nitems > 0)		ret = workspace[0];	XFree (workspace);	return ret;#else	/* FIXME: on mac etc proably there are native APIs	 * to get the current workspace etc */	return 0;#endif}

static voidempathy_video_widget_sync_message_cb (GstBus *bus, GstMessage *message,  EmpathyVideoWidget *self){  EmpathyVideoWidgetPriv *priv = GET_PRIV (self);  const GstStructure *s;  if (GST_MESSAGE_TYPE (message) != GST_MESSAGE_ELEMENT)    return;  if (GST_MESSAGE_SRC (message) != (GstObject *) priv->overlay)    return;  s = gst_message_get_structure (message);  if (gst_structure_has_name (s, "prepare-xwindow-id"))    {      gst_x_overlay_set_xwindow_id (GST_X_OVERLAY (priv->overlay),        GDK_WINDOW_XID (GTK_WIDGET (self)->window));    }}

voidqtcWindowStatusBarDBus(GtkWidget *widget, gboolean state){    GtkWindow *topLevel = GTK_WINDOW(gtk_widget_get_toplevel(widget));    unsigned int xid = GDK_WINDOW_XID(gtk_widget_get_window(GTK_WIDGET(topLevel)));    char cmd[160];    //sprintf(cmd, "qdbus org.kde.kwin /QtCurve statusBarState %u %s", xid, state ? "true" : "false");    sprintf(cmd, "dbus-send --type=method_call --session --dest=org.kde.kwin /QtCurve org.kde.QtCurve.statusBarState uint32:%u boolean:%s",            xid, state ? "true" : "false");    system(cmd);    /*      char         xidS[16],      stateS[6];      char         *args[]={"qdbus", "org.kde.kwin", "/QtCurve", "statusBarState", xidS, stateS, NULL};      sprintf(xidS, "%u", xid);      sprintf(stateS, "%s", state ? "true" : "false");      g_spawn_async("/tmp", args, NULL, (GSpawnFlags)0, NULL, NULL, NULL, NULL);    */}

voidqtcWindowMenuBarDBus(GtkWidget *widget, int size){    GtkWindow *topLevel = GTK_WINDOW(gtk_widget_get_toplevel(widget));    unsigned int xid = GDK_WINDOW_XID(gtk_widget_get_window(GTK_WIDGET(topLevel)));    char cmd[160];    //sprintf(cmd, "qdbus org.kde.kwin /QtCurve menuBarSize %u %d", xid, size);    sprintf(cmd, "dbus-send --type=method_call --session --dest=org.kde.kwin /QtCurve org.kde.QtCurve.menuBarSize uint32:%u int32:%d",            xid, size);    system(cmd);    /*      char         xidS[16],      sizeS[16];      char         *args[]={"qdbus", "org.kde.kwin", "/QtCurve", "menuBarSize", xidS, sizeS, NULL};      sprintf(xidS, "%u", xid);      sprintf(sizeS, "%d", size);      g_spawn_async("/tmp", args, NULL, (GSpawnFlags)0, NULL, NULL, NULL, NULL);    */}

static voidon_realize (GtkWidget *dialog,            gpointer  data){    Window xid;    xid = (Window) GPOINTER_TO_INT (data);#if GTK_CHECK_VERSION(3, 22, 0)    gdk_x11_display_error_trap_push (gtk_widget_get_display (dialog));#else    gdk_error_trap_push ();#endif    XSetTransientForHint (gdk_x11_get_default_xdisplay (),                          GDK_WINDOW_XID (gtk_widget_get_window (dialog)),                          xid);#if GTK_CHECK_VERSION(3, 22, 0)    gdk_x11_display_error_trap_pop_ignored (gtk_widget_get_display (dialog));#else    gdk_error_trap_pop_ignored ();#endif}

/** * @brief * @param ui The GstSwitchUI instance. * @param view * @param handle * @param port * @memberof GstSwitchUI */static GstAudioVisual *gst_switch_ui_new_audio_visual_unsafe (GstSwitchUI * ui, GtkWidget * view,    gulong handle, gint port){  gchar *name = g_strdup_printf ("visual-%d", port);  GstAudioVisual *visual;  if (view && handle == 0) {    GdkWindow *xview = gtk_widget_get_window (view);    handle = GDK_WINDOW_XID (xview);  }  visual =      GST_AUDIO_VISUAL (g_object_new      (GST_TYPE_AUDIO_VISUAL, "name", name, "port", port,          "handle", handle, "active", (ui->audio_port == port), NULL));  g_free (name);  if (!gst_worker_start (GST_WORKER (visual)))    ERROR ("failed to start audio visual");  return visual;}

voidpanel_warp_pointer (GdkWindow *gdk_window,		    int        x,		    int        y){	Display *display;	Window   window;	g_return_if_fail (GDK_IS_WINDOW (gdk_window));	display = GDK_WINDOW_XDISPLAY (gdk_window);	window = GDK_WINDOW_XID (gdk_window);	gdk_error_trap_push ();	XWarpPointer (display, None, window, 0, 0, 0, 0, x, y);#if GTK_CHECK_VERSION (3, 0, 0)	gdk_error_trap_pop_ignored ();#else	gdk_error_trap_pop ();#endif}

static voiddraw_background (GnomeBGCrossfade *fade){	if (gdk_window_get_window_type (fade->priv->window) == GDK_WINDOW_ROOT) {		gdk_error_trap_push ();                XClearArea (GDK_WINDOW_XDISPLAY (fade->priv->window),                            GDK_WINDOW_XID (fade->priv->window),                            0, 0,                            gdk_window_get_width (fade->priv->window),                            gdk_window_get_height (fade->priv->window),                            False);                send_root_property_change_notification (fade);		gdk_flush ();		gdk_error_trap_pop (); // ignore errors	} else {		gdk_window_invalidate_rect (fade->priv->window, NULL, FALSE);		gdk_window_process_updates (fade->priv->window, FALSE);	}}

/////////////////////////////////////////////////////////////// Construct the wxSFMLCanvas////////////////////////////////////////////////////////////wxSFMLCanvas::wxSFMLCanvas(wxWindow *Parent,                           wxWindowID Id,                           const wxPoint &Position,                           const wxSize &Size,                           long Style)    : wxControl(Parent, Id, Position, Size, Style) {#ifdef __WXGTK__  // GTK implementation requires to go deeper to find the low-level X11  // identifier of the widget  gtk_widget_realize(m_wxwindow);  gtk_widget_set_double_buffered(m_wxwindow, false);  GtkWidget *privHandle = m_wxwindow;  wxPizza *pizza = WX_PIZZA(privHandle);  GtkWidget *widget = GTK_WIDGET(pizza);// Get the internal gtk window...#if GTK_CHECK_VERSION(3, 0, 0)  GdkWindow *win = gtk_widget_get_window(widget);#else  GdkWindow *win = widget->window;#endif  XFlush(GDK_WINDOW_XDISPLAY(win));//...and pass it to the sf::RenderWindow.#if GTK_CHECK_VERSION(3, 0, 0)  sf::RenderWindow::create(GDK_WINDOW_XID(win));#else  sf::RenderWindow::create(GDK_WINDOW_XWINDOW(win));#endif#else  // Tested under Windows XP only (should work with X11 and other Windows  // versions - no idea about MacOS)  sf::RenderWindow::create(static_cast<sf::WindowHandle>(GetHandle()));#endif}

/** * gedit_utils_get_current_workspace: Get the current workspace * * Get the currently visible workspace for the #GdkScreen. * * If the X11 window property isn't found, 0 (the first workspace) * is returned. */guintgedit_utils_get_current_workspace (GdkScreen *screen){#ifdef GDK_WINDOWING_X11	GdkWindow *root_win;	GdkDisplay *display;	Atom type;	gint format;	gulong nitems;	gulong bytes_after;	guint *current_desktop;	gint err, result;	guint ret = 0;	g_return_val_if_fail (GDK_IS_SCREEN (screen), 0);	root_win = gdk_screen_get_root_window (screen);	display = gdk_screen_get_display (screen);	gdk_error_trap_push ();	result = XGetWindowProperty (GDK_DISPLAY_XDISPLAY (display), GDK_WINDOW_XID (root_win),				     gdk_x11_get_xatom_by_name_for_display (display, "_NET_CURRENT_DESKTOP"),				     0, G_MAXLONG, False, XA_CARDINAL, &type, &format, &nitems,				     &bytes_after, (gpointer) &current_desktop);	err = gdk_error_trap_pop ();	if (err != Success || result != Success)		return ret;	if (type == XA_CARDINAL && format == 32 && nitems > 0)		ret = current_desktop[0];	XFree (current_desktop);	return ret;#else	/* FIXME: on mac etc proably there are native APIs	 * to get the current workspace etc */	return 0;#endif}

static intgs_grab_get_mouse (GSGrab    *grab,                   GdkWindow *window,                   GdkScreen *screen,                   gboolean   hide_cursor){    GdkGrabStatus status;    GdkCursor    *cursor;    g_return_val_if_fail (window != NULL, FALSE);    g_return_val_if_fail (screen != NULL, FALSE);    cursor = get_cursor ();    gs_debug ("Grabbing mouse widget=%X", (guint32) GDK_WINDOW_XID (window));    status = gdk_pointer_grab (window, TRUE, 0, NULL,                               (hide_cursor ? cursor : NULL),                               GDK_CURRENT_TIME);    if (status == GDK_GRAB_SUCCESS)    {        if (grab->priv->mouse_grab_window != NULL)        {            g_object_remove_weak_pointer (G_OBJECT (grab->priv->mouse_grab_window),                                          (gpointer *) &grab->priv->mouse_grab_window);        }        grab->priv->mouse_grab_window = window;        g_object_add_weak_pointer (G_OBJECT (grab->priv->mouse_grab_window),                                   (gpointer *) &grab->priv->mouse_grab_window);        grab->priv->mouse_grab_screen = screen;        grab->priv->mouse_hide_cursor = hide_cursor;    }    gdk_cursor_unref (cursor);    return status;}

// MUST be called from the GTK main thread; calling it in OnRealized will do the right thing.P_INVOKE voidbp_video_window_realize (BansheePlayer *player, GdkWindow *window){    g_return_if_fail (IS_BANSHEE_PLAYER (player));// Code commented out - this requires including gtk/gtk.h for GTK_CHECK_VERSION, which requires too many// buildsystem changes for the benefit of a single debug message in the failure case.////#if GTK_CHECK_VERSION(2,18,0)//    //Explicitly create the native window.  GDK_WINDOW_XWINDOW will call this//    //function anyway, but this way we can raise a more useful message should it fail.//    if (!gdk_window_ensure_native (window)) {//        banshee_log (BANSHEE_LOG_TYPE_ERROR, "player-video", "Couldn't create native window needed for GstXOverlay!");//    }//#endif#if defined(GDK_WINDOWING_X11)    player->video_window_xid = GDK_WINDOW_XID (window);#elif defined (GDK_WINDOWING_WIN32)    player->video_window_xid = GDK_WINDOW_HWND (window);#endif}

static gboolean on_ref_configure(GtkWidget *widget, GdkEvent  *event,               gpointer   user_data){    g_debug("%s", __func__);    GdkEventConfigure *gec = (GdkEventConfigure*)event;    g_width = gec->width;    g_height = gec->height;    gtk_window_resize(GTK_WINDOW(top), g_width, g_height);    if (!gtk_widget_get_mapped(ref)) return TRUE;    if (back_pixmap) {        glXDestroyPixmap(display, glx_pm);        XFreePixmap(display, back_pixmap);        GdkWindow* gdkwin = gtk_widget_get_window(ref);        back_pixmap = XCompositeNameWindowPixmap(display, GDK_WINDOW_XID(gdkwin));        glx_pm = glXCreatePixmap(display, bestFbc, back_pixmap, pixmap_attribs);    }    return TRUE;}

void Player_ControlsGUI::on_playbutton_pressed(){  // The UI changes :)     m_playbutton.set_sensitive(false);  m_pausebutton.set_sensitive();  m_previousbutton.set_sensitive();  m_nextbutton.set_sensitive();  m_openbutton.set_sensitive(false);  m_stopbutton.set_sensitive();	  m_playbutton.hide();  m_pausebutton.show();// then call up the list// and place the uri into the engine//engine.get_File(list.find_item(index));//then engage the play statemedia_uri = list.find_item(index);std::cout<< "Test for linked list out put !!!"<<std::endl;std::cout<< media_uri<<std::endl;//engine.get_File("/home/william/Videos/season 1/Hunter X Hunter 2011 Episode 1.flv");//engine.set_winID(player_window_id);//engine.stopState();engine.get_File(media_uri);engine.set_winID(GDK_WINDOW_XID(video_area.get_window()->gobj()));set_screen_resize(640,480);//data = engine.report();engine.playState();// clear the string after use index++;m_timeout_connection = Glib::signal_timeout().connect(    sigc::mem_fun(*this, &Player_ControlsGUI::update), 200);  }

gbooleanqtcMenuEmitSize(GtkWidget *w, unsigned int size){    if (w) {        QTC_DEF_WIDGET_PROPS(props, w);        unsigned oldSize = qtcWidgetProps(props)->menuBarSize;        if (oldSize != size) {            GtkWidget *topLevel = gtk_widget_get_toplevel(w);            xcb_window_t wid =                GDK_WINDOW_XID(gtk_widget_get_window(GTK_WIDGET(topLevel)));            if (size == 0xFFFF) {                size = 0;            }            qtcWidgetProps(props)->menuBarSize = size;            qtcX11SetMenubarSize(wid, size);            return true;        }    }    return false;}

static gintluaH_window_index(lua_State *L, luapdf_token_t token){    widget_t *w = luaH_checkwidget(L, 1);    switch(token)    {      LUAPDF_WIDGET_BIN_INDEX_COMMON(w)      LUAPDF_WIDGET_CONTAINER_INDEX_COMMON(w)      /* push widget class methods */      PF_CASE(DESTROY, luaH_widget_destroy)      PF_CASE(FOCUS,   luaH_widget_focus)      PF_CASE(HIDE,    luaH_widget_hide)      /* push window class methods */      PF_CASE(SET_DEFAULT_SIZE, luaH_window_set_default_size)      PF_CASE(SHOW,             luaH_window_show)      PF_CASE(SET_SCREEN,       luaH_window_set_screen)      PF_CASE(FULLSCREEN,       luaH_window_fullscreen)      PF_CASE(UNFULLSCREEN,     luaH_window_unfullscreen)      PF_CASE(MAXIMIZE,         luaH_window_maximize)      PF_CASE(UNMAXIMIZE,       luaH_window_unmaximize)      /* push string methods */      PS_CASE(TITLE, gtk_window_get_title(GTK_WINDOW(w->widget)))      /* push boolean properties */      PB_CASE(DECORATED, gtk_window_get_decorated(GTK_WINDOW(w->widget)))      case L_TK_XID:        lua_pushnumber(L, GDK_WINDOW_XID(GTK_WIDGET(w->widget)->window));        return 1;      default:        break;    }    return 0;}

cairo_surface_t *create_native_surface_and_wrap (int        w,                                int        h,                                GtkWidget *parent_style_window){    GdkWindow       *window;    GdkVisual       *visual;    cairo_surface_t *surface;    Display         *display;    Pixmap           pixmap;    if (w <= 0 || h <= 0)	abort ();    display = GDK_DISPLAY_XDISPLAY (gdk_display_get_default ());    window = gtk_widget_get_window (parent_style_window);    visual = gdk_window_get_visual (window);    pixmap = XCreatePixmap (display, GDK_WINDOW_XID (window), w, h, gdk_visual_get_depth (visual));    surface = cairo_xlib_surface_create (display, pixmap, GDK_VISUAL_XVISUAL (visual), w, h);    return surface;}