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

/* This function will make sure that tilda window becomes active (gains * the focus) when it is called. * * This has to be the worst possible way of making this work, but it was the * only way to get metacity to play nicely. All the other WM's are so nice, * why oh why does metacity hate us so? */void tilda_window_set_active (tilda_window *tw){    DEBUG_FUNCTION ("tilda_window_set_active");    DEBUG_ASSERT (tw != NULL);    Display *x11_display = GDK_WINDOW_XDISPLAY (gtk_widget_get_window (tw->window) );    Window x11_window = GDK_WINDOW_XID (gtk_widget_get_window (tw->window) );    Window x11_root_window = GDK_WINDOW_XID ( gtk_widget_get_root_window (tw->window) );    GdkScreen *screen = gtk_widget_get_screen (tw->window);    XEvent event;    long mask = SubstructureRedirectMask | SubstructureNotifyMask;    gtk_window_move (GTK_WINDOW(tw->window), config_getint ("x_pos"), config_getint ("y_pos"));    if (gdk_x11_screen_supports_net_wm_hint (screen,                                             gdk_atom_intern_static_string ("_NET_ACTIVE_WINDOW")))    {        guint32 timestamp = gtk_get_current_event_time ();        if (timestamp == 0) {            timestamp = gdk_x11_get_server_time(gtk_widget_get_root_window (tw->window));        }        event.xclient.type = ClientMessage;        event.xclient.serial = 0;        event.xclient.send_event = True;        event.xclient.display = x11_display;        event.xclient.window = x11_window;        event.xclient.message_type = gdk_x11_get_xatom_by_name ("_NET_ACTIVE_WINDOW");        event.xclient.format = 32;        event.xclient.data.l[0] = 2; /* pager */        event.xclient.data.l[1] = timestamp; /* timestamp */        event.xclient.data.l[2] = 0;        event.xclient.data.l[3] = 0;        event.xclient.data.l[4] = 0;        XSendEvent (x11_display, x11_root_window, False, mask, &event);    }    else    {        /* The WM doesn't support the EWMH standards. We'll print a warning and         * try this, though it probably won't work... */        g_printerr (_("WARNING: Window manager (%s) does not support EWMH hints/n"),                    gdk_x11_screen_get_window_manager_name (screen));        XRaiseWindow (x11_display, x11_window);    }}

gbooleanturn (gpointer user_data){  static double place = 0.0;  place++;  while (place>360.0)    {      place -= 360.0;    }  XMoveWindow (GDK_WINDOW_XDISPLAY (window->window),	       GDK_WINDOW_XID (window->window),	       100+100*sin(place*(M_PI/180)),	       100+100*cos(place*(M_PI/180)));  return TRUE;}

static voiddraw_background (GnomeBGCrossfade *fade){	if (gdk_window_get_window_type (fade->priv->window) == GDK_WINDOW_ROOT) {                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 ();	} else {		gdk_window_invalidate_rect (fade->priv->window, NULL, FALSE);		gdk_window_process_updates (fade->priv->window, FALSE);	}}

/* * Need to get GdkWindow after invoke gtk_widget_show() and gtk_main() */static gbooleanhave_extension (InputPadGtkWindow *window){    int opcode = 0;    int event  = 0;    int error  = 0;    g_return_val_if_fail (window != NULL &&                          INPUT_PAD_IS_GTK_WINDOW (window), FALSE);    if (!XQueryExtension (GDK_WINDOW_XDISPLAY (gtk_widget_get_window (GTK_WIDGET (window))),                         "XTEST", &opcode, &event, &error)) {        g_warning ("Could not find XTEST module. Maybe you did not install "                   "libXtst library./n"                   "%% xdpyinfo | grep XTEST");        return FALSE;    }    return TRUE;}

static gbooleaninput_pad_xkb_init (InputPadGtkWindow *window){    static gboolean retval = FALSE;    Display *xdisplay = GDK_WINDOW_XDISPLAY (gtk_widget_get_window (GTK_WIDGET (window)));    if (retval) {        return retval;    }    if (!XkbQueryExtension (xdisplay, NULL, NULL, NULL, NULL, NULL)) {        g_warning ("Could not init XKB");        return FALSE;    }    XkbInitAtoms (NULL);    retval = TRUE;    return TRUE;}

/////////////////////////////////////////////////////////////// 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);        GdkWindow* Win = GTK_PIZZA(m_wxwindow)->bin_window;        XFlush(GDK_WINDOW_XDISPLAY(Win));        sf::RenderWindow::Create(GDK_WINDOW_XWINDOW(Win));    #else        // Tested under Windows XP only (should work with X11 and other Windows versions - no idea about MacOS)        sf::RenderWindow::create(GetHandle());        #endif}

static voidshortcut_edited_cb(GtkCellRendererText   *cell,		   const char            *path_string,		   guint                  keyval,		   EggVirtualModifierType mask,		   guint		  keycode,		   gpointer               data){  Vnkb 		*vnkb 	 = (Vnkb*)data;  GtkTreeModel 	*model 	 = GTK_TREE_MODEL(vnkb->store);  GtkTreePath 	*path 	 = gtk_tree_path_new_from_string (path_string);  GtkTreeIter 	 iter;  KeyEntry 	*key_entry, tmp_key;  GError 	*err 	 = NULL;  char 		*str;  GdkWindow 	*gdkroot = gdk_get_default_root_window();  Display 	*display = GDK_WINDOW_XDISPLAY(gdkroot);  gtk_tree_model_get_iter (model, &iter, path);  gtk_tree_model_get (model, &iter,		      1, &key_entry,		      -1);  /* sanity check */  if (key_entry == NULL) {    gtk_tree_path_free (path);    return;  }  tmp_key.keyval = keyval;  tmp_key.keycode = keycode;  tmp_key.mask   = mask;  *key_entry = tmp_key;  gtk_tree_model_row_changed (model, path, &iter);  gtk_tree_path_free (path);  vnkb->xvnkb->hotkey.state = mask;  vnkb->xvnkb->hotkey.sym   = XKeycodeToKeysym(display,keycode,0);  if (vnkb->xvnkb->hotkey.state & VK_SHIFT)    vnkb->xvnkb->hotkey.sym = toupper(vnkb->xvnkb->hotkey.sym);  vnkb_xvnkb_update_switchkey(vnkb);}

/* OGLCanvas::OGLCanvas * OGLCanvas class constructor, SFML implementation *******************************************************************/OGLCanvas::OGLCanvas(wxWindow* parent, int id, bool handle_timer): wxControl(parent, id, wxDefaultPosition, wxDefaultSize, wxBORDER_NONE|wxWANTS_CHARS), timer(this) {	init_done = false;	last_time = theApp->runTimer();	if (handle_timer)		timer.Start(100);	// Code taken from SFML wxWidgets integration example	sf::WindowHandle handle;#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);	GdkWindow* Win = gtk_widget_get_window(m_wxwindow);	XFlush(GDK_WINDOW_XDISPLAY(Win));	//sf::RenderWindow::Create(GDK_WINDOW_XWINDOW(Win));	handle = GDK_WINDOW_XWINDOW(Win);#else	handle = GetHandle();#endif#if SFML_VERSION_MAJOR < 2	sf::RenderWindow::Create(handle);#else	// Context settings	sf::ContextSettings settings;	settings.depthBits = 32;	settings.stencilBits = 8;	sf::RenderWindow::create(handle, settings);#endif	// Bind events	Bind(wxEVT_PAINT, &OGLCanvas::onPaint, this);	Bind(wxEVT_ERASE_BACKGROUND, &OGLCanvas::onEraseBackground, this);	//Bind(wxEVT_IDLE, &OGLCanvas::onIdle, this);	if (handle_timer)		Bind(wxEVT_TIMER, &OGLCanvas::onTimer, this);}

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

void MdispGtkView::X11Annotations( bool on )   {   m_isX11AnnotationsEnabled = on;   if(on)      {      gtk_widget_queue_draw_area(m_window,0,0,1,1);      }   // make sur the window is mapped   else if(m_window->window)      {      XEvent ev;      ev.type = Expose;      ev.xexpose.window = GDK_WINDOW_XID(m_window->window);      ev.xexpose.x = 0;      ev.xexpose.y = 0;      ev.xexpose.width  = m_window->allocation.width;      ev.xexpose.height = m_window->allocation.height;      XSendEvent(GDK_WINDOW_XDISPLAY(m_window->window),GDK_WINDOW_XID(m_window->window), true, ExposureMask, &ev);      }	   }

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}

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

bool wxTopLevelWindowGTK::SetTransparent(wxByte alpha){    if (m_widget == NULL)        return false;#if GTK_CHECK_VERSION(2,12,0)#ifndef __WXGTK3__    if (gtk_check_version(2,12,0) == NULL)#endif    {        gtk_window_set_opacity(GTK_WINDOW(m_widget), alpha / 255.0);        return true;    }#endif // GTK_CHECK_VERSION(2,12,0)#ifndef __WXGTK3__#ifdef GDK_WINDOWING_X11    GdkWindow* window = gtk_widget_get_window(m_widget);    if (window == NULL)        return false;    Display* dpy = GDK_WINDOW_XDISPLAY(window);    Window win = GDK_WINDOW_XID(window);    if (alpha == 0xff)        XDeleteProperty(dpy, win, XInternAtom(dpy, "_NET_WM_WINDOW_OPACITY", False));    else    {        long opacity = alpha * 0x1010101L;        XChangeProperty(dpy, win, XInternAtom(dpy, "_NET_WM_WINDOW_OPACITY", False),                        XA_CARDINAL, 32, PropModeReplace,                        (unsigned char *) &opacity, 1L);    }    XSync(dpy, False);    return true;#else // !GDK_WINDOWING_X11    return false;#endif // GDK_WINDOWING_X11 / !GDK_WINDOWING_X11#endif // !__WXGTK3__}

static voidegg_tray_manager_set_orientation_property (EggTrayManager *manager){#ifdef GDK_WINDOWING_X11  gulong data[1];  if (!manager->invisible || !manager->invisible->window)    return;  g_assert (manager->orientation_atom != None);  data[0] = manager->orientation == GTK_ORIENTATION_HORIZONTAL ?		SYSTEM_TRAY_ORIENTATION_HORZ :		SYSTEM_TRAY_ORIENTATION_VERT;  XChangeProperty (GDK_WINDOW_XDISPLAY (manager->invisible->window),		   GDK_WINDOW_XWINDOW (manager->invisible->window),		   manager->orientation_atom,		   XA_CARDINAL, 32,		   PropModeReplace,		   (guchar *) &data, 1);#endif}

// this function will make sure that everything has been initialized.nsresultnsScreenManagerGtk :: EnsureInit(){  if (mCachedScreenArray.Count() > 0)    return NS_OK;  mRootWindow = gdk_get_default_root_window();  g_object_ref(mRootWindow);  // GDK_STRUCTURE_MASK ==> StructureNotifyMask, for ConfigureNotify  // GDK_PROPERTY_CHANGE_MASK ==> PropertyChangeMask, for PropertyNotify  gdk_window_set_events(mRootWindow,                        GdkEventMask(gdk_window_get_events(mRootWindow) |                                     GDK_STRUCTURE_MASK |                                     GDK_PROPERTY_CHANGE_MASK));  gdk_window_add_filter(mRootWindow, root_window_event_filter, this);#ifdef MOZ_X11  mNetWorkareaAtom =    XInternAtom(GDK_WINDOW_XDISPLAY(mRootWindow), "_NET_WORKAREA", False);#endif  return Init();}

/** * hildon_remote_texture_send_message: * @self: A #HildonRemoteTexture * @message_type: Message id for the remote texture message. * @l0: 1st remote texture message parameter. * @l1: 2nd remote texture message parameter. * @l2: 3rd remote texture message parameter. * @l3: 4th remote texture message parameter. * @l4: 5th remote texture message parameter. * * Sends an X11 ClientMessage event to the window manager with * the specified parameters -- id (@message_type) and data (@l0, * @l1, @l2, @l3, @l4). * * This is an internal utility function that application will * not need to call directly. * * Since: 2.2 **/voidhildon_remote_texture_send_message (HildonRemoteTexture *self,                                     guint32 message_type,                                     guint32 l0,                                     guint32 l1,                                     guint32 l2,                                     guint32 l3,                                     guint32 l4){    GtkWidget          *widget = GTK_WIDGET (self);    Display            *display = GDK_WINDOW_XDISPLAY (widget->window);    Window              window = GDK_WINDOW_XID (widget->window);    XEvent event = { 0 };    event.xclient.type = ClientMessage;    event.xclient.window = window;    event.xclient.message_type = (Atom)message_type;    event.xclient.format = 32;    event.xclient.data.l[0] = l0;    event.xclient.data.l[1] = l1;    event.xclient.data.l[2] = l2;    event.xclient.data.l[3] = l3;    event.xclient.data.l[4] = l4;#if 0    g_debug ("%lu (%lu %lu %lu %lu %lu) -> %lu/n",             message_type,             l0, l1, l2, l3, l4,             window);#endif    XSendEvent (display, window, True,                StructureNotifyMask,                (XEvent *)&event);}

void OGLCanvas::createSFML(){#ifdef USE_SFML_RENDERWINDOW	// Code taken from SFML wxWidgets integration example	sf::WindowHandle handle;#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);	GdkWindow* Win = gtk_widget_get_window(m_wxwindow);	XFlush(GDK_WINDOW_XDISPLAY(Win));	// sf::RenderWindow::Create(GDK_WINDOW_XWINDOW(Win));	handle = GDK_WINDOW_XWINDOW(Win);#else	handle = GetHandle();#endif	// Context settings	sf::ContextSettings settings;	settings.depthBits   = 24;	settings.stencilBits = 8;	sf::RenderWindow::create(handle, settings);#endif}

/** * _gtk_xembed_send_message: * @recipient: (allow-none): window to which to send the window, or %NULL *             in which case nothing will be sent * @message:   type of message * @detail:    detail field of message * @data1:     data1 field of message * @data2:     data2 field of message *  * Sends a generic XEMBED message to a particular window. **/void_gtk_xembed_send_message (GdkWindow        *recipient,			  XEmbedMessageType message,			  glong             detail,			  glong             data1,			  glong             data2){  GdkDisplay *display;  XClientMessageEvent xclient;  if (!recipient)    return;	    g_return_if_fail (GDK_IS_WINDOW (recipient));  display = gdk_window_get_display (recipient);  GTK_NOTE (PLUGSOCKET,	    g_message ("Sending %s", _gtk_xembed_message_name (message)));  memset (&xclient, 0, sizeof (xclient));  xclient.window = GDK_WINDOW_XID (recipient);  xclient.type = ClientMessage;  xclient.message_type = gdk_x11_get_xatom_by_name_for_display (display, "_XEMBED");  xclient.format = 32;  xclient.data.l[0] = gtk_xembed_get_time ();  xclient.data.l[1] = message;  xclient.data.l[2] = detail;  xclient.data.l[3] = data1;  xclient.data.l[4] = data2;  gdk_x11_display_error_trap_push (display);  XSendEvent (GDK_WINDOW_XDISPLAY(recipient),	      GDK_WINDOW_XID (recipient),	      False, NoEventMask, (XEvent *)&xclient);  gdk_x11_display_error_trap_pop_ignored (display);}

bool wxTopLevelWindowGTK::SetTransparent(wxByte alpha){    if (!m_widget || !m_widget->window)        return false;    Display* dpy = GDK_WINDOW_XDISPLAY (m_widget->window);    // We need to get the X Window that has the root window as the immediate parent    // and m_widget->window as a child. This should be the X Window that the WM manages and    // from which the opacity property is checked from.    Window win = wxGetTopmostWindowX11(dpy, GDK_WINDOW_XID (m_widget->window));    // Using pure Xlib to not have a GTK version check mess due to gtk2.0 not having GdkDisplay    if (alpha == 0xff)        XDeleteProperty(dpy, win, XInternAtom(dpy, "_NET_WM_WINDOW_OPACITY", False));    else    {        long opacity = alpha * 0x1010101L;        XChangeProperty(dpy, win, XInternAtom(dpy, "_NET_WM_WINDOW_OPACITY", False),                        XA_CARDINAL, 32, PropModeReplace,                        (unsigned char *) &opacity, 1L);    }    XSync(dpy, False);    return true;}

LOCAL_SYMBOL MetaWindowMenu*meta_window_menu_new   (MetaFrames         *frames,                        MetaMenuOp          ops,                        MetaMenuOp          insensitive,                        Window              client_xwindow,                        unsigned long       active_workspace,                        int                 n_workspaces,                        MetaWindowMenuFunc  func,                        gpointer            data){  int i;  MetaWindowMenu *menu;  /* FIXME: Modifications to 'ops' should happen in meta_window_show_menu */  if (n_workspaces < 2)    ops &= ~(META_MENU_OP_STICK | META_MENU_OP_UNSTICK | META_MENU_OP_WORKSPACES);    menu = g_new (MetaWindowMenu, 1);  menu->frames = frames;  menu->client_xwindow = client_xwindow;  menu->func = func;  menu->data = data;  menu->ops = ops;  menu->insensitive = insensitive;      menu->menu = gtk_menu_new ();  gtk_menu_set_screen (GTK_MENU (menu->menu),                       gtk_widget_get_screen (GTK_WIDGET (frames)));  for (i = 0; i < (int) G_N_ELEMENTS (menuitems); i++)    {      MenuItem menuitem = menuitems[i];      if (ops & menuitem.op || menuitem.op == 0)        {          GtkWidget *mi;          MenuData *md;          unsigned int key;          MetaVirtualModifier mods;          mi = menu_item_new (&menuitem, -1);          /* Set the activeness of radiobuttons. */          switch (menuitem.op)            {            case META_MENU_OP_STICK:              gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mi),                                              active_workspace == 0xFFFFFFFF);              break;            case META_MENU_OP_UNSTICK:              gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mi),                                              active_workspace != 0xFFFFFFFF);              break;            default:              break;            }          if (menuitem.type == MENU_ITEM_WORKSPACE_LIST)            {              if (ops & META_MENU_OP_WORKSPACES)                {                  Display *display;                  Window xroot;                  GdkScreen *screen;                  GdkWindow *window;                  GtkWidget *submenu;                  int j;                  MenuItem to_another_workspace = {                    0, MENU_ITEM_NORMAL,                    NULL, FALSE,                    N_("Move to Another _Workspace")                  };                  meta_verbose ("Creating %d-workspace menu current space %lu/n",                      n_workspaces, active_workspace);                  window = gtk_widget_get_window (GTK_WIDGET (frames));                  display = GDK_WINDOW_XDISPLAY (window);                  screen = gdk_window_get_screen (window);                  xroot = GDK_WINDOW_XID (gdk_screen_get_root_window (screen));                  submenu = gtk_menu_new ();                  g_assert (mi==NULL);                  mi = menu_item_new (&to_another_workspace, -1);                  gtk_menu_item_set_submenu (GTK_MENU_ITEM (mi), submenu);                  for (j = 0; j < n_workspaces; j++)                    {                      char *label;                      MenuData *md;                      unsigned int key;                      MetaVirtualModifier mods;                      MenuItem moveitem;                      GtkWidget *submi;                      meta_core_get_menu_accelerator (META_MENU_OP_WORKSPACES,                          j + 1,//.........这里部分代码省略.........

voidgu_video_create(gu_nav_page_t *gnp){  prop_courier_t *pc = gnp->gnp_gt->gt_gw->gw_gu->gu_pc;  struct video_output *vo;  char errbuf[256];  char buf[512];  gu_video_t *gv;    gnp->gnp_pageroot = gtk_drawing_area_new();  gtk_container_add(GTK_CONTAINER(gnp->gnp_pagebin), gnp->gnp_pageroot);  gtk_widget_show_all(gnp->gnp_pageroot);  vo = x11_vo_create(GDK_WINDOW_XDISPLAY(gnp->gnp_pageroot->window),		     GDK_WINDOW_XID(gnp->gnp_pageroot->window),		     pc, gnp->gnp_prop, errbuf, sizeof(errbuf));  if(vo == NULL) {    gtk_widget_destroy(gnp->gnp_pageroot);    snprintf(buf, sizeof(buf), "Unable to start video: %s", errbuf);    gnp->gnp_pageroot = gtk_label_new(buf);    gtk_container_add(GTK_CONTAINER(gnp->gnp_pagebin), gnp->gnp_pageroot);    gtk_widget_show_all(gnp->gnp_pageroot);    return;  }  gv = calloc(1, sizeof(gu_video_t));  gv->gv_closeprop = prop_ref_inc(prop_create(gnp->gnp_prop, "close"));  gv->gv_status_sub =     prop_subscribe(0,		   PROP_TAG_NAME("self", "media", "playstatus"),		   PROP_TAG_CALLBACK_STRING, video_set_playstatus, gv,		   PROP_TAG_COURIER, pc,		   PROP_TAG_NAMED_ROOT, gnp->gnp_prop, "self",		   NULL);  g_signal_connect(GTK_OBJECT(gnp->gnp_pageroot), 		   "destroy", G_CALLBACK(video_destroy), gv);  g_signal_connect(G_OBJECT(gnp->gnp_pageroot), 		   "expose_event",                    G_CALLBACK(expose_event_callback), vo);  g_signal_connect_after(G_OBJECT(gnp->gnp_pageroot), 		   "configure_event",                    G_CALLBACK(configure_event_callback), vo);  g_signal_connect(GTK_OBJECT(gnp->gnp_pageroot), 		   "unrealize", G_CALLBACK(video_unrealize), vo);  g_signal_connect(G_OBJECT(gnp->gnp_pageroot), 		   "button-press-event", 		   G_CALLBACK(mouse_press), gnp);  gtk_widget_add_events(gnp->gnp_pageroot, 			GDK_BUTTON_PRESS_MASK |			GDK_BUTTON_RELEASE_MASK);  gu_page_set_fullwindow(gnp, 1);}

static void accessx_status_applet_update(AccessxStatusApplet* sapplet, AccessxStatusNotifyType notify_type, XkbEvent* event){    GdkWindow* window;    gint i;    window = gtk_widget_get_window(GTK_WIDGET(sapplet->applet));    if (notify_type & ACCESSX_STATUS_MODIFIERS)    {        unsigned int locked_mods = 0, latched_mods = 0;        if (event != NULL)        {            locked_mods = event->state.locked_mods;            latched_mods = event->state.latched_mods;        }        else if (sapplet->applet && window)        {            XkbStateRec state;            XkbGetState(GDK_WINDOW_XDISPLAY(window), XkbUseCoreKbd, &state);            locked_mods = state.locked_mods;            latched_mods = state.latched_mods;        }        /* determine which modifiers are locked, and set state accordingly */        for (i = 0; i < G_N_ELEMENTS(modifiers); ++i)        {            if (modifiers[i].indicator != NULL && modifiers[i].mask)            {                if (locked_mods & modifiers[i].mask)                {                    gtk_widget_set_sensitive(modifiers[i].indicator, TRUE);#if GTK_CHECK_VERSION (3, 0, 0)                    gtk_widget_set_state_flags (modifiers[i].indicator, GTK_STATE_FLAG_SELECTED, TRUE);#else                    gtk_widget_set_state(modifiers[i].indicator, GTK_STATE_SELECTED);#endif                }                else if (latched_mods & modifiers[i].mask)                {                    gtk_widget_set_sensitive(modifiers[i].indicator, TRUE);#if GTK_CHECK_VERSION (3, 0, 0)                    gtk_widget_set_state_flags (modifiers[i].indicator, GTK_STATE_FLAG_NORMAL, TRUE);#else                    gtk_widget_set_state(modifiers[i].indicator, GTK_STATE_NORMAL);#endif                }                else                {                    gtk_widget_set_sensitive(modifiers[i].indicator, FALSE);                }            }        }    }    if ((notify_type & ACCESSX_STATUS_SLOWKEYS) && (event != NULL))    {        GdkPixbuf* pixbuf = accessx_status_applet_slowkeys_image(sapplet, &event->accessx);        gtk_image_set_from_pixbuf(GTK_IMAGE(sapplet->slowfoo), pixbuf);        g_object_unref(pixbuf);    }    if ((notify_type & ACCESSX_STATUS_BOUNCEKEYS) && (event != NULL))    {        GdkPixbuf* pixbuf = accessx_status_applet_bouncekeys_image(sapplet, &event->accessx);        gtk_image_set_from_pixbuf(GTK_IMAGE(sapplet->bouncefoo), pixbuf);        g_object_unref(pixbuf);    }    if (notify_type & ACCESSX_STATUS_MOUSEKEYS)    {        GdkPixbuf* pixbuf = accessx_status_applet_mousekeys_image(sapplet, &event->state);        gtk_image_set_from_pixbuf(GTK_IMAGE(sapplet->mousefoo),  pixbuf);        g_object_unref(pixbuf);    }    if (notify_type & ACCESSX_STATUS_ENABLED)    {        /* Update the visibility of widgets in the box */        /* XkbMouseKeysMask | XkbStickyKeysMask | XkbSlowKeysMask | XkbBounceKeysMask */        XkbGetControls(GDK_WINDOW_XDISPLAY(window), XkbAllControlsMask, sapplet->xkb);        if (!(sapplet->xkb->ctrls->enabled_ctrls & (XkbMouseKeysMask | XkbStickyKeysMask | XkbSlowKeysMask | XkbBounceKeysMask)))        {            gtk_widget_show(sapplet->idlefoo);        }        else        {            gtk_widget_hide(sapplet->idlefoo);        }        if (sapplet->xkb->ctrls->enabled_ctrls & XkbMouseKeysMask)        {            gtk_widget_show(sapplet->mousefoo);        }        else        {            gtk_widget_hide(sapplet->mousefoo);        }        if (sapplet->xkb->ctrls->enabled_ctrls & XkbStickyKeysMask)//.........这里部分代码省略.........

static GdkPixbuf* accessx_status_applet_slowkeys_image(AccessxStatusApplet* sapplet, XkbAccessXNotifyEvent* event){    GdkPixbuf* ret_pixbuf;    GdkWindow* window;    gboolean is_idle = TRUE;    gchar* stock_id = SLOWKEYS_IDLE_ICON;    GtkStyle* style = gtk_widget_get_style(GTK_WIDGET(sapplet->applet));    GdkColor bg = style->bg[GTK_STATE_NORMAL];    if (event != NULL)    {        is_idle = FALSE;        switch (event->detail)        {        case XkbAXN_SKPress:            stock_id = ACCESSX_BASE_ICON;            if (_sk_timeout)            {                g_source_remove(_sk_timeout);                _sk_timeout = 0;            }            break;        case XkbAXN_SKAccept:            stock_id = ACCESSX_ACCEPT_BASE;            gdk_color_parse("#009900", &bg);            break;        case XkbAXN_SKReject:            stock_id = ACCESSX_REJECT_BASE;            gdk_color_parse("#990000", &bg);            _sk_timeout = g_timeout_add_full(G_PRIORITY_HIGH_IDLE, MAX(event->sk_delay, 150), timer_reset_slowkeys_image, sapplet->slowfoo, NULL);            break;        case XkbAXN_SKRelease:        default:            stock_id = SLOWKEYS_IDLE_ICON;            is_idle = TRUE;            break;        }    }    ret_pixbuf = gtk_widget_render_icon(GTK_WIDGET(sapplet->applet), stock_id, icon_size_spec, NULL);    if (!is_idle)    {        GdkPixbuf* glyph_pixbuf;        GdkPixbuf* tmp_pixbuf;        GdkColor  fg;        gchar* glyphstring = N_("a");        tmp_pixbuf = ret_pixbuf;        ret_pixbuf = gdk_pixbuf_copy(tmp_pixbuf);        g_object_unref(tmp_pixbuf);        window = gtk_widget_get_window(GTK_WIDGET(sapplet->applet));        if (event && window)        {            KeySym keysym = XKeycodeToKeysym(GDK_WINDOW_XDISPLAY(window), event->keycode, 0);            glyphstring = XKeysymToString(keysym);            if ((!g_utf8_validate(glyphstring, -1, NULL)) || (g_utf8_strlen(glyphstring, -1) > 1))            {                glyphstring = "";            }        }#if GTK_CHECK_VERSION (3, 0, 0)        fg = style->fg[gtk_widget_get_state_flags (GTK_WIDGET (sapplet->applet))];#else        fg = style->fg[gtk_widget_get_state(GTK_WIDGET(sapplet->applet))];#endif        glyph_pixbuf = accessx_status_applet_get_glyph_pixbuf(sapplet, GTK_WIDGET(sapplet->applet), ret_pixbuf, &fg, &bg, glyphstring);        gdk_pixbuf_composite(glyph_pixbuf, ret_pixbuf, 0, 0, gdk_pixbuf_get_width(glyph_pixbuf), gdk_pixbuf_get_height(glyph_pixbuf), 0., 0., 1.0, 1.0, GDK_INTERP_NEAREST, 255);        g_object_unref(glyph_pixbuf);    }    return ret_pixbuf;}

GdkGrabStatus_gdk_windowing_pointer_grab (GdkWindow *window,			     GdkWindow *native,			     gboolean owner_events,			     GdkEventMask event_mask,			     GdkWindow *confine_to,			     GdkCursor *cursor,			     guint32 time){  gint return_val;  GdkCursorPrivate *cursor_private;  GdkDisplayX11 *display_x11;  guint xevent_mask;  Window xwindow;  Window xconfine_to;  Cursor xcursor;  int i;  if (confine_to)    confine_to = _gdk_window_get_impl_window (confine_to);  display_x11 = GDK_DISPLAY_X11 (GDK_WINDOW_DISPLAY (native));  cursor_private = (GdkCursorPrivate*) cursor;  xwindow = GDK_WINDOW_XID (native);  if (!confine_to || GDK_WINDOW_DESTROYED (confine_to))    xconfine_to = None;  else    xconfine_to = GDK_WINDOW_XID (confine_to);  if (!cursor)    xcursor = None;  else    {      _gdk_x11_cursor_update_theme (cursor);      xcursor = cursor_private->xcursor;    }  xevent_mask = 0;  for (i = 0; i < _gdk_nenvent_masks; i++)    {      if (event_mask & (1 << (i + 1)))	xevent_mask |= _gdk_event_mask_table[i];    }  /* We don't want to set a native motion hint mask, as we're emulating motion   * hints. If we set a native one we just wouldn't get any events.   */  xevent_mask &= ~PointerMotionHintMask;  return_val = _gdk_input_grab_pointer (window,					native,					owner_events,					event_mask,					confine_to,					time);  if (return_val == GrabSuccess ||      G_UNLIKELY (!display_x11->trusted_client && return_val == AlreadyGrabbed))    {      if (!GDK_WINDOW_DESTROYED (native))	{#ifdef G_ENABLE_DEBUG	  if (_gdk_debug_flags & GDK_DEBUG_NOGRABS)	    return_val = GrabSuccess;	  else#endif	    return_val = XGrabPointer (GDK_WINDOW_XDISPLAY (native),				       xwindow,				       owner_events,				       xevent_mask,				       GrabModeAsync, GrabModeAsync,				       xconfine_to,				       xcursor,				       time);	}      else	return_val = AlreadyGrabbed;    }  if (return_val == GrabSuccess)    _gdk_x11_roundtrip_async (GDK_DISPLAY_OBJECT (display_x11),			      has_pointer_grab_callback,			      NULL);  return gdk_x11_convert_grab_status (return_val);}

gintmain (gint argc, gchar *argv[]){    Window root;    //gettext    bindtextdomain( "gamine", LOCALDIR );    textdomain( "gamine" );    gamine_t cb;    GtkWidget *window;    GdkWindow *gdkwindow;    GtkWindow *gtkwindow;    GdkScreen *screen;    GdkPixbuf *cursor_pixbuf;    GdkPixbuf *icon_pixbuf;    GdkCursor *cursor;    GdkColor bg_color;    gchar *cursorfile;    gchar *iconfile;    cb.is_cairo = FALSE;    gtk_init (&argc, &argv);    gst_init (&argc, &argv);    gconf_init(argc, argv, NULL);    gst_play_background (cb.bus,              "BachJSBrandenburgConcertNo2inFMajorBWV1047mvmt1.ogg", TRUE);    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);/* Create the drawing area and configuration */    cb.da = gtk_drawing_area_new ();    bg_color.red   = 65535;    bg_color.green = 65535;    bg_color.blue  = 65535;    gtk_widget_modify_bg (cb.da, GTK_STATE_NORMAL, &bg_color);    gtk_container_add (GTK_CONTAINER (window), cb.da);    cb.gc = gconf_client_get_default();    gtkwindow = GTK_WINDOW(window);    gtk_window_set_title (gtkwindow, "Gamine");    gtk_window_set_wmclass(gtkwindow, "gamine", "Gamine");    gtk_container_set_border_width (GTK_CONTAINER (gtkwindow), 0);/* Event signals */    g_signal_connect (gtkwindow, "destroy",         G_CALLBACK (gtk_main_quit), &gtkwindow);    g_signal_connect (G_OBJECT (cb.da), "expose-event",        G_CALLBACK (display_help), &cb);    g_signal_connect (cb.da, "motion_notify_event",        G_CALLBACK (draw_line), &cb);    g_signal_connect (cb.da, "button_press_event",        G_CALLBACK (draw_star), &cb);    g_signal_connect (gtkwindow, "key-press-event",        G_CALLBACK (gamine_on_key), &cb);    gtk_widget_set_events (cb.da, gtk_widget_get_events (cb.da)        | GDK_LEAVE_NOTIFY_MASK        | GDK_BUTTON_PRESS_MASK        | GDK_BUTTON_RELEASE_MASK        | GDK_POINTER_MOTION_MASK        | GDK_POINTER_MOTION_HINT_MASK);/* Set fullscreen, grab mouse/keyboard, ...*/    gtk_widget_show_all (GTK_WIDGET(gtkwindow));    gdkwindow = GDK_WINDOW(GTK_WIDGET(gtkwindow)->window);    screen = gtk_widget_get_screen (cb.da);    gtk_window_present (gtkwindow);    gtk_window_stick(gtkwindow);    //gtk_window_set_keep_above (gtkwindow), True);    //gtk_window_set_transient_for (gtkwindow, NULL);    //set fullscreen    gdk_window_fullscreen (gdkwindow);    gtk_window_fullscreen (gtkwindow);    gdk_window_raise (gdkwindow);    //set full screen without window manager    XMoveResizeWindow(GDK_WINDOW_XDISPLAY(gdkwindow), GDK_WINDOW_XID(gdkwindow),        0, 0, gdk_screen_get_width (screen), gdk_screen_get_height (screen));    root = DefaultRootWindow(GDK_WINDOW_XDISPLAY (gdkwindow));    XGrabPointer(GDK_WINDOW_XDISPLAY (gdkwindow), root, True, PointerMotionMask,        GrabModeAsync, GrabModeAsync, root, None, CurrentTime);     XGrabKeyboard(GDK_WINDOW_XDISPLAY (gdkwindow), root, True,                    GrabModeAsync, GrabModeAsync, CurrentTime);    //remove keyboard repeat    XAutoRepeatOff(GDK_WINDOW_XDISPLAY (gdkwindow));    gtk_window_has_toplevel_focus (gtkwindow);/*cursor*/    cursorfile = g_build_filename(DATADIR, "pencil.png", NULL);    if (!g_file_test (cursorfile, G_FILE_TEST_EXISTS)) {        printf(gettext("*** error: %s does not exists***/n"), cursorfile);    } else {        cursor_pixbuf = gdk_pixbuf_new_from_file(cursorfile, NULL);        cursor = gdk_cursor_new_from_pixbuf(gdk_display_get_default(),            cursor_pixbuf, 0, 38);        gdk_window_set_cursor(gdkwindow, cursor);        gdk_cursor_unref(cursor);        gdk_pixbuf_unref(cursor_pixbuf);    }    g_free(cursorfile);/*Set icon*/    iconfile = g_build_filename(DATADIR, "gamine.png", NULL);    if (!g_file_test (iconfile, G_FILE_TEST_EXISTS))        printf(gettext("*** error: %s does not exists***/n"), iconfile);//.........这里部分代码省略.........

void wxOgre::createOgreRenderWindow(){	// See if an Ogre::Root already exists	mRoot = Ogre::Root::getSingletonPtr();  	mRenderWindow = mRoot->initialise(false);	// --------------------	// Create a new parameters list according to compiled OS	Ogre::NameValuePairList params;	Ogre::String handle;#ifdef __WXMSW__	handle = Ogre::StringConverter::toString((size_t)((HWND)GetHandle()));	params["externalWindowHandle"] = handle;#elif defined(__WXGTK__)	SetBackgroundStyle(wxBG_STYLE_CUSTOM);	GtkWidget* privHandle = GetHandle();    	// prevents flickering	gtk_widget_set_double_buffered(privHandle, FALSE);    // this doesn't work w. Ogre 1.6.1 maybe this will fix it?    gtk_widget_realize(privHandle);   	// grab the window object	GdkWindow* gdkWin = GTK_PIZZA(privHandle)->bin_window;	Display* display = GDK_WINDOW_XDISPLAY(gdkWin);	Window wid = GDK_WINDOW_XWINDOW(gdkWin);    XSync(display,wid);	std::stringstream str;	// display	str << (unsigned long)display << ':';	// screen (returns "display.screen")	std::string screenStr = DisplayString(display);	std::string::size_type dotPos = screenStr.find(".");	screenStr = screenStr.substr(dotPos+1, screenStr.size());	str << screenStr << ':';	// XID	str << wid << ':';	// retrieve XVisualInfo	int attrlist[] = { GLX_RGBA, GLX_DOUBLEBUFFER, GLX_DEPTH_SIZE, 16, GLX_STENCIL_SIZE, 8, None };	XVisualInfo* vi = glXChooseVisual(display, DefaultScreen(display), attrlist);	str << (unsigned long)vi;	handle = str.str();        #else#error Not supported on this platform.#endif	// Get wx control window size	int width;	int height;	GetSize(&width, &height);	// Create the render window	mRenderWindow = Ogre::Root::getSingleton().createRenderWindow("OgreRenderWindow", width, height, false, &params);    // line is required, otherwise the screen does not update    mRenderWindow->setActive(true);    	// --------------------	// Create the SceneManager, in this case a generic one	mSceneMgr = mRoot->createSceneManager(Ogre::ST_GENERIC, "ExampleSMInstance");	mSceneMgr->setAmbientLight(Ogre::ColourValue(0.5f, 0.5f, 0.5f));		// --------------------	// Create the camera	mCamera = mSceneMgr->createCamera("EntityCamera");	// Set up the SceneNodes to control the camera	mCameraNode = mSceneMgr->getRootSceneNode()->createChildSceneNode();	mCameraNode->attachObject(mCamera);	mCamera->setNearClipDistance(0.1);	// Set the viewport	mViewPort = mRenderWindow->addViewport(mCamera); 	// Set the background to match the wxWindow background color	mViewPort->setBackgroundColour(Ogre::ColourValue(212.0f/255.0f, 208.0f/255.0f, 200.0f/255.0f, 1.0f)); 	//mLightNode = mCameraNode->createChildSceneNode();    mXLight = mSceneMgr->createLight("XLight");    mXLight->setType(Ogre::Light::LT_DIRECTIONAL);    mXLight->setDiffuseColour(1.0f, 1.0f,1.0f);    mXLight->setDirection(-1.0f, 0.0f, 0.0f);     mYLight = mSceneMgr->createLight("YLight");    mYLight->setType(Ogre::Light::LT_DIRECTIONAL);    mYLight->setDiffuseColour(1.0f, 1.0f,1.0f);    mYLight->setDirection(0.0f, -1.0f, 0.0f);     mZLight = mSceneMgr->createLight("ZLight");//.........这里部分代码省略.........

voidmy_gdk_draw_text(GdkDrawable *drawable,                 GdkFont     *font,                 GdkGC       *gc,                 gint         x,                 gint         y,                 const gchar *text,                 gint         text_length){#ifdef MOZ_WIDGET_GTK  GdkWindowPrivate *drawable_private;  GdkFontPrivate *font_private;  GdkGCPrivate *gc_private;#endif /* MOZ_WIDGET_GTK */  g_return_if_fail (drawable != NULL);  g_return_if_fail (font != NULL);  g_return_if_fail (gc != NULL);  g_return_if_fail (text != NULL);#ifdef MOZ_WIDGET_GTK  drawable_private = (GdkWindowPrivate*) drawable;  if (drawable_private->destroyed)    return;  gc_private = (GdkGCPrivate*) gc;  font_private = (GdkFontPrivate*) font;#endif /* MOZ_WIDGET_GTK */#ifdef MOZ_WIDGET_GTK2  if (GDK_IS_WINDOW(drawable) && GDK_WINDOW_OBJECT(drawable)->destroyed)    return;#endif /* MOZ_WIDGET_GTK2 */  if (font->type == GDK_FONT_FONT)  {#ifdef MOZ_WIDGET_GTK    XFontStruct *xfont = (XFontStruct *) font_private->xfont;#endif /* MOZ_WIDGET_GTK */#ifdef MOZ_WIDGET_GTK2    XFontStruct *xfont = (XFontStruct *) GDK_FONT_XFONT(font);#endif /* MOZ_WIDGET_GTK2 */    // gdk does this... we don't need it..    //    XSetFont(drawable_private->xdisplay, gc_private->xgc, xfont->fid);    // We clamp the sizes down to 32768 which is the maximum width of    // a window.  Even if a font was 1 pixel high and started at the    // left, the maximum size of a draw request could only be 32k.    if ((xfont->min_byte1 == 0) && (xfont->max_byte1 == 0))    {#ifdef MOZ_WIDGET_GTK      XDrawString (drawable_private->xdisplay, drawable_private->xwindow,                   gc_private->xgc, x, y, text, MIN(text_length, 32768));#endif /* MOZ_WIDGET_GTK */#ifdef MOZ_WIDGET_GTK2      XDrawString (GDK_WINDOW_XDISPLAY(drawable), GDK_DRAWABLE_XID(drawable),                   GDK_GC_XGC(gc), x, y, text, MIN(text_length, 32768));#endif /* MOZ_WIDGET_GTK2 */    }    else    {#ifdef MOZ_WIDGET_GTK      XDrawString16 (drawable_private->xdisplay, drawable_private->xwindow,                     gc_private->xgc, x, y, (XChar2b *) text,                      MIN((text_length / 2), 32768));#endif /* MOZ_WIDGET_GTK */#ifdef MOZ_WIDGET_GTK2      XDrawString16 (GDK_WINDOW_XDISPLAY(drawable), GDK_DRAWABLE_XID(drawable),                     GDK_GC_XGC(gc), x, y, (XChar2b *) text,                      MIN((text_length / 2), 32768));#endif /* MOZ_WIDGET_GTK2 */    }  }  else if (font->type == GDK_FONT_FONTSET)  {#ifdef MOZ_WIDGET_GTK    XFontSet fontset = (XFontSet) font_private->xfont;    XmbDrawString (drawable_private->xdisplay, drawable_private->xwindow,                   fontset, gc_private->xgc, x, y, text, text_length);#endif /* MOZ_WIDGET_GTK */#ifdef MOZ_WIDGET_GTK2    XFontSet fontset = (XFontSet) GDK_FONT_XFONT(font);    XmbDrawString (GDK_WINDOW_XDISPLAY(drawable), GDK_DRAWABLE_XID(drawable),                   fontset, GDK_GC_XGC(gc), x, y, text, text_length);#endif /* MOZ_WIDGET_GTK2 */  }  else    g_error("undefined font type/n");}