static void show_cursor (Doppelganger *dg) { int current_pointer; XIEventMask mask = { dg->mpx, 0, "" }; #if 0 /* probably unnecessary */ XIGetClientPointer (gdk_x11_get_default_xdisplay (), None, ¤t_pointer); /* probably unnecessary */ XISetClientPointer (gdk_x11_get_default_xdisplay (), None, dg->mpx); if (XIGrabDevice (gdk_x11_get_default_xdisplay (), dg->mpx, GDK_ROOT_WINDOW(), CurrentTime, gdk_x11_cursor_get_xcursor (dg->cursor), GrabModeAsync, GrabModeAsync, True, &mask) != GrabSuccess) { g_warning ("Grab failed."); } /* probably unnecessary */ XISetClientPointer (gdk_x11_get_default_xdisplay (), None, current_pointer); #endif }
void frame_update_shadow (decor_frame_t *frame, decor_shadow_info_t *info, decor_shadow_options_t *opt_active_shadow, decor_shadow_options_t *opt_inactive_shadow) { static decor_shadow_options_t no_shadow = {0.0, 0.0, {0, 0, 0}, 0, 0}; gwd_decor_frame_ref (frame); info->active = TRUE; (*frame->update_shadow) (gdk_x11_get_default_xdisplay (), gdk_x11_screen_get_xscreen (gdk_screen_get_default ()), frame, &frame->border_shadow_active, &frame->window_context_active, &frame->max_border_shadow_active, &frame->max_window_context_active, info, opt_active_shadow, &no_shadow); info->active = FALSE; (*frame->update_shadow) (gdk_x11_get_default_xdisplay (), gdk_x11_screen_get_xscreen (gdk_screen_get_default ()), frame, &frame->border_shadow_inactive, &frame->window_context_inactive, &frame->max_border_shadow_inactive, &frame->max_window_context_inactive, info, opt_inactive_shadow, &no_shadow); gwd_decor_frame_unref (frame); }
void my_wnck_change_state (Screen *screen, Window xwindow, gboolean add, Atom state1, Atom state2) { 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.display = gdk_x11_get_default_xdisplay (); xev.xclient.window = xwindow; xev.xclient.message_type = my_wnck_atom_get ("_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] = state1; xev.xclient.data.l[2] = state2; XSendEvent (gdk_x11_get_default_xdisplay (), RootWindowOfScreen (screen), False, SubstructureRedirectMask | SubstructureNotifyMask, &xev); }
static int add_mpx_for_window (char *name) { XIAddMasterInfo add; int ndevices; XIDeviceInfo *devices, *device; int i; int result; /* add the device */ add.type = XIAddMaster; add.name = name; add.send_core = True; add.enable = True; XIChangeHierarchy (gdk_x11_get_default_xdisplay (), (XIAnyHierarchyChangeInfo*) &add, 1); /* now see whether it's in the list */ result = -1; devices = XIQueryDevice(gdk_x11_get_default_xdisplay (), XIAllDevices, &ndevices); for (i = 0; i < ndevices; i++) { device = &devices[i]; if (g_str_has_prefix (device->name, name)) { switch (device->use) { case XIMasterPointer: result = device->deviceid; break; } } } if (result==-1) { g_warning ("The doppelganger pointer '%s' could not be created.", name); } XIFreeDeviceInfo(devices); return result; }
GdkWindow* create_wrapper(GdkWindow* parent, Window tray_icon) { gdk_flush(); GdkWindow* icon = gdk_x11_window_foreign_new_for_display(gdk_display_get_default(), tray_icon); if (icon == NULL) return NULL; GdkVisual* visual = gdk_window_get_visual(icon); GdkWindow* wrapper = NULL; if (gdk_visual_get_depth(visual) == 24) { GdkWindowAttr attributes; attributes.width = DEFAULT_HEIGHT; attributes.height = DEFAULT_HEIGHT; attributes.window_type = GDK_WINDOW_CHILD; attributes.wclass = GDK_INPUT_OUTPUT; attributes.event_mask = GDK_ALL_EVENTS_MASK; attributes.visual = visual; wrapper = gdk_window_new(parent, &attributes, GDK_WA_VISUAL); //TODO: there should set color correspond by dock background color /*GdkColor color = {1, 0, 0, 1};*/ /*gdk_window_set_background_rgba(wrapper, &color);*/ XReparentWindow(gdk_x11_get_default_xdisplay(), tray_icon, GDK_WINDOW_XID(wrapper), 0, 0); gdk_window_show(icon); g_object_set_data(G_OBJECT(wrapper), "wrapper_child", icon); g_object_set_data(G_OBJECT(icon), "wrapper_parent", wrapper); } else { wrapper = icon; } return wrapper; }
static void avatar_image_add_filter (EmpathyAvatarImage *avatar_image) { Display *display; Window window; gint mask; XWindowAttributes attrs; if (!running_in_x11 ()) return; mask = PropertyChangeMask; window = gdk_x11_get_default_root_xwindow (); display = gdk_x11_get_default_xdisplay (); gdk_error_trap_push (); XGetWindowAttributes (display, window, &attrs); mask |= attrs.your_event_mask; XSelectInput (display, window, mask); gdk_error_trap_pop_ignored (); gdk_window_add_filter (NULL, avatar_image_filter_func, avatar_image); }
static void add_device_presence_filter (GsdPointingDeviceManager *manager) { Display *display; XEventClass class_presence; gint xi_presence; gint op_code, event, error; if (!XQueryExtension(GDK_DISPLAY(), "XInputExtension", &op_code, &event, &error)) { return; } display = gdk_x11_get_default_xdisplay(); gdk_error_trap_push(); DevicePresence(display, xi_presence, class_presence); XSelectExtensionEvent(display, RootWindow(display, DefaultScreen(display)), &class_presence, 1); gdk_flush(); if (!gdk_error_trap_pop()) gdk_window_add_filter(NULL, device_presence_filter, manager); }
void background_info_set_background_by_drawable(BackgroundInfo* info, guint32 drawable) { gint x, y; guint border,depth, width=0, height=0; Display* dpy = gdk_x11_get_default_xdisplay(); gdk_error_trap_push(); //TODO: //we shoul use xatom_name window to set events instead of root window //because the monitors changed signal will came before root window rect changed //so the Xroot window rect maybe keep old rect in update_bg function and in Display DBus signal "PrimaryChanged" Window root; XGetGeometry(dpy, drawable, &root, &x, &y, &width, &height, &border, &depth); g_debug("[%s] width: %d, height: %d, x: %d y: %d\n", __func__, width, height, x, y); if (gdk_error_trap_pop()) { g_warning("[%s] invalid drawable %d \n", __func__, drawable); return; } g_mutex_lock(&info->m); if (info->bg != NULL) { cairo_surface_destroy(info->bg); info->bg = NULL; } info->bg = cairo_xlib_surface_create(dpy, drawable, gdk_x11_visual_get_xvisual(gdk_visual_get_system()), width, height); g_mutex_unlock(&info->m); if (gtk_widget_get_realized(info->container)) { gdk_window_invalidate_rect(gtk_widget_get_window(info->container), NULL, TRUE); } }
static struct QsDrawX11Context *qsDrawX11Context_create(GtkWidget *w) { struct QsDrawX11Context *x; x = g_malloc0(sizeof(*x)); x->dsp = gdk_x11_get_default_xdisplay(); QS_ASSERT(x->dsp); x->xwin = gdk_x11_window_get_xid(gtk_widget_get_window(w)); QS_ASSERT(x->xwin); x->cmap = DefaultColormap(x->dsp, DefaultScreen(x->dsp)); QS_ASSERT(x->cmap); x->gc = XCreateGC(x->dsp, x->xwin, 0, 0); QS_ASSERT(x->gc); x->bg.pixel = 0; x->bg.red = 0x0001; /* X11 uses shorts not bytes */ x->bg.green = 0xFFFF; x->bg.blue = 0xFFFF; x->bg.flags = 0; #ifdef QS_DEBUG QS_ASSERT(XAllocColor(x->dsp, x->cmap, &x->bg)); #else XAllocColor(x->dsp, x->cmap, &x->bg); #endif return x; }
/* * From eggcellrenderkeys.c. */ gboolean tomboy_keybinder_is_modifier (guint keycode) { gint i; gint map_size; XModifierKeymap *mod_keymap; gboolean retval = FALSE; mod_keymap = XGetModifierMapping (gdk_x11_get_default_xdisplay ()); map_size = 8 * mod_keymap->max_keypermod; i = 0; while (i < map_size) { if (keycode == mod_keymap->modifiermap[i]) { retval = TRUE; break; } ++i; } XFreeModifiermap (mod_keymap); return retval; }
void ss_thumbnailer_free (SSThumbnailer *thumbnailer) { Display *display; display = gdk_x11_get_default_xdisplay (); if (thumbnailer == NULL) { return; } if (thumbnailer->thumbnail_pixmap != NULL) { g_object_unref (thumbnailer->thumbnail_pixmap); thumbnailer->thumbnail_pixmap = NULL; } if (thumbnailer->thumbnail_picture != None) { XRenderFreePicture (display, thumbnailer->thumbnail_picture); thumbnailer->thumbnail_picture = None; } if (thumbnailer->window_picture != None) { XRenderFreePicture (display, thumbnailer->window_picture); thumbnailer->window_picture = None; } g_free (thumbnailer); }
bool wxTopLevelWindowGTK::CanSetTransparent() { // allow to override automatic detection as it's far from perfect const wxString SYSOPT_TRANSPARENT = "gtk.tlw.can-set-transparent"; if ( wxSystemOptions::HasOption(SYSOPT_TRANSPARENT) ) { return wxSystemOptions::GetOptionInt(SYSOPT_TRANSPARENT) != 0; } #ifdef __WXGTK3__ return gtk_widget_is_composited(m_widget) != 0; #else #if GTK_CHECK_VERSION(2,10,0) if (!gtk_check_version(2,10,0)) { return gtk_widget_is_composited(m_widget) != 0; } else #endif // In case of lower versions than gtk+-2.10.0 we could look for _NET_WM_CM_Sn ourselves { return false; } #endif // !__WXGTK3__ #if 0 // Don't be optimistic here for the sake of wxAUI int opcode, event, error; // Check for the existence of a RGBA visual instead? return XQueryExtension(gdk_x11_get_default_xdisplay (), "Composite", &opcode, &event, &error); #endif }
void gtk_gl_swap_buffers (GtkWidget *widget) { Display *display = gdk_x11_get_default_xdisplay (); Window window = gdk_x11_window_get_xid (gtk_widget_get_window (widget)); glXSwapBuffers (display, window); }
// This code can only run after thumbnailer's drawing_area has been realized, // and after the main loop has run so that wnck_window is initialized. static void initialize_thumbnailer_pictures (SSThumbnailer *thumbnailer) { Display *display; GdkScreen *screen; XRenderPictFormat *format; XRenderPictureAttributes pa; display = gdk_x11_get_default_xdisplay (); screen = gtk_widget_get_screen (thumbnailer->drawing_area); format = XRenderFindVisualFormat (display, DefaultVisual ( display, gdk_screen_get_number (screen))); thumbnailer->thumbnail_pixmap = gdk_pixmap_new ( thumbnailer->drawing_area->window, THUMBNAIL_SIZE, THUMBNAIL_SIZE, -1); thumbnailer->thumbnail_picture = XRenderCreatePicture (display, GDK_DRAWABLE_XID (thumbnailer->thumbnail_pixmap), format, 0, NULL); pa.subwindow_mode = IncludeInferiors; thumbnailer->window_picture = XRenderCreatePicture (display, wnck_window_get_xid (thumbnailer->wnck_window), format, CPSubwindowMode, &pa); XRenderSetPictureFilter (display, thumbnailer->window_picture, "good", NULL, 0); }
void gtk_gl_enable (GtkWidget *widget) { GdkScreen *screen; GdkVisual *visual; Display *xdisplay; XVisualInfo *xvi; gint xscreen; GtkGLContext *gtkgc; gint attributes[] ={GLX_RGBA, GLX_RED_SIZE, 8, GLX_GREEN_SIZE, 8, GLX_BLUE_SIZE, 8, GLX_DEPTH_SIZE,24, GLX_DOUBLEBUFFER, None}; gtk_widget_set_app_paintable (widget, TRUE); gtk_widget_set_double_buffered (widget, FALSE); gtkgc = g_slice_new0 (GtkGLContext); xdisplay = gdk_x11_get_default_xdisplay (); xscreen = gdk_x11_get_default_screen (); g_return_if_fail (NULL != (xvi = glXChooseVisual (xdisplay, xscreen, attributes))); screen = gtk_widget_get_screen (widget); g_return_if_fail (NULL != (visual = gdk_x11_screen_lookup_visual (screen, xvi->visualid))); gtk_widget_set_visual (widget, visual); gtkgc->widget = widget; g_return_if_fail (NULL != (gtkgc->context = glXCreateContext (xdisplay, xvi, NULL, GL_TRUE))); gtk_glx_context_list = g_slist_prepend (gtk_glx_context_list, gtkgc); }
Atom my_wnck_atom_get (const char *atom_name) { Atom retval; g_return_val_if_fail (atom_name != NULL, None); if (!atom_hash) { atom_hash = g_hash_table_new (g_str_hash, g_str_equal); reverse_atom_hash = g_hash_table_new (NULL, NULL); } retval = GPOINTER_TO_UINT (g_hash_table_lookup (atom_hash, atom_name)); if (!retval) { retval = XInternAtom (gdk_x11_get_default_xdisplay (), atom_name, FALSE); if (retval != None) { char *name_copy; name_copy = g_strdup (atom_name); g_hash_table_insert (atom_hash, name_copy, GUINT_TO_POINTER (retval)); g_hash_table_insert (reverse_atom_hash, GUINT_TO_POINTER (retval), name_copy); } } return retval; }
static GdkFilterReturn device_presence_filter (GdkXEvent *xevent, GdkEvent *event, gpointer data) { XEvent *xev = (XEvent *)xevent; XEventClass class_presence; int xi_presence; GpdsXInput *xinput; GsdPointingDeviceManager *manager = GSD_POINTING_DEVICE_MANAGER(data); xinput = gsd_pointing_device_manager_get_xinput(manager); if (!xinput) return GDK_FILTER_CONTINUE; DevicePresence(gdk_x11_get_default_xdisplay(), xi_presence, class_presence); if (xev->type == xi_presence) { XDevicePresenceNotifyEvent *notify_event = (XDevicePresenceNotifyEvent *)xev; if (notify_event->devchange == DeviceEnabled || notify_event->devchange == DeviceRemoved) { set_disable_while_other_device_exists(manager, xinput, gconf_client_get_default()); } } g_object_unref(xinput); return GDK_FILTER_CONTINUE; }
static void cem_gl_area_configure(GtkWidget *area, gpointer data) { GLint attributes[] = { GLX_RGBA, GLX_DEPTH_SIZE, 24, GLX_DOUBLEBUFFER, None}; CemGLAreaPrivate *priv; gtk_widget_set_double_buffered(area, FALSE); priv = cem_gl_area_get_instance_private(area); priv->drawing_window = gtk_widget_get_window(GTK_WIDGET(area)); priv->x_window = gdk_x11_window_get_xid(GDK_WINDOW(priv->drawing_window)); priv->x_display = gdk_x11_get_default_xdisplay(); priv->x_visual = glXChooseVisual(priv->x_display, 0, attributes); priv->x_context = glXCreateContext(priv->x_display, priv->x_visual, NULL, GL_TRUE); XGetWindowAttributes(priv->x_display, priv->x_window, &priv->x_attributes); glXMakeCurrent(priv->x_display, priv->x_window, priv->x_context); XMapWindow(priv->x_display, priv->x_window); glViewport(0, 0, priv->x_attributes.width, priv->x_attributes.height); glOrtho(-10, 10, -10, 10, -10, 10); glScalef(5.0, 5.0, 5.0); }
CD_APPLET_ON_CLICK_END //\___________ Define here the entries you want to add to the menu when the user right-clicks on your icon or on its subdock or your desklet. The icon and the container that were clicked are available through the macros CD_APPLET_CLICKED_ICON and CD_APPLET_CLICKED_CONTAINER. CD_APPLET_CLICKED_ICON may be NULL if the user clicked in the container but out of icons. The menu where you can add your entries is available throught the macro CD_APPLET_MY_MENU; you can add sub-menu to it if you want. #ifdef HAVE_X11 #ifdef HAVE_XRANDR static void _on_select_resolution (GtkMenuItem *menu_item, gpointer data) /// TODO: put that in the core... { CD_APPLET_ENTER; int iNumRes = GPOINTER_TO_INT (data); Display *dpy; Window root; XRRScreenConfiguration *conf; short *rates; int num_rates; dpy = gdk_x11_get_default_xdisplay (); root = RootWindow(dpy, 0); conf = XRRGetScreenInfo(dpy, root); CD_APPLET_LEAVE_IF_FAIL (conf != NULL); //g_return_if_fail (conf != NULL); rates = XRRRates(dpy, 0, iNumRes, &num_rates); CD_APPLET_LEAVE_IF_FAIL (num_rates > 0); //g_return_if_fail (num_rates > 0); cd_debug ("available rates : from %d to %d Hz", rates[0], rates[num_rates-1]); XRRSetScreenConfigAndRate(dpy, conf, root, iNumRes, RR_Rotate_0, rates[num_rates-1], CurrentTime); XRRFreeScreenConfigInfo (conf); // restore original conf : XRRSetScreenConfigAndRate(dpy, conf, root, original_size_id, original_rotation, original_rate, CurrentTime); CD_APPLET_LEAVE(); }
static gboolean key_event( GtkWidget *input, GdkEventKey *event ) { XKeyEvent xevent; switch( event->type ) { case GDK_KEY_PRESS: xevent.type = KeyPress; break; case GDK_KEY_RELEASE: xevent.type = KeyRelease; break; default: return FALSE; } xevent.display = gdk_x11_get_default_xdisplay(); xevent.keycode = event->hardware_keycode; xevent.state = event->state; xevent.time = event->time; xevent.root = gdk_x11_get_default_root_xwindow(); window_list_foreach_selected( wl, window_list_foreach_callback, &xevent ); return TRUE; }
void CFont::CloseXftFont( XftFont* font ) { if( font ) { Display *display = gdk_x11_get_default_xdisplay(); XftFontClose(display, font ); } }
/** * Initialises appropriate X extensions. */ static void initialise_extensions (void) { int major = 2, minor = 0; if (XIQueryVersion(gdk_x11_get_default_xdisplay (), &major, &minor) == BadRequest) { g_error("XI2 not available. Server supports %d.%d\n", major, minor); } }
gboolean uninit_composite (void) { XCompositeUnredirectSubwindows (gdk_x11_get_default_xdisplay (), GDK_WINDOW_XWINDOW (gdk_get_default_root_window ()), CompositeRedirectAutomatic); return TRUE; }
int c_center(lua_State *lua) { int top = lua_gettop(lua); int workspace_width, workspace_height, window_width, window_height; int xoffset, yoffset; WnckScreen *screen; WnckWorkspace *workspace; if (top != 0) { luaL_error(lua, "center: %s", no_indata_expected_error); return 0; } WnckWindow *window = get_current_window(); if (!window) { lua_pushboolean(lua, FALSE); return 1; } wnck_window_get_geometry(window, NULL, NULL, &window_width, &window_height); screen = wnck_window_get_screen(window); workspace = wnck_screen_get_active_workspace(screen); if (workspace == NULL) { workspace = wnck_screen_get_workspace(screen,0); } if (workspace == NULL) { g_printerr(_("Could not get workspace")); lua_pushboolean(lua, FALSE); return 1; } workspace_width = wnck_workspace_get_width(workspace); workspace_height = wnck_workspace_get_height(workspace); xoffset = (workspace_width - window_width) / 2; yoffset = (workspace_height - window_height) / 2; devilspie2_error_trap_push(); XMoveWindow (gdk_x11_get_default_xdisplay(), wnck_window_get_xid(window), xoffset, yoffset); if (devilspie2_error_trap_pop()) { g_printerr("center: %s", failed_string); lua_pushboolean(lua, FALSE); return 1; } lua_pushboolean(lua, TRUE); return 1; }
void gtk_gl_make_current (GtkWidget *widget) { Display *display = gdk_x11_get_default_xdisplay (); Window window = gdk_x11_window_get_xid (gtk_widget_get_window (widget)); GSList *node = gtk_glx_get_context (widget); GtkGLContext *gtkgc = node->data; g_return_if_fail (True == glXMakeCurrent (display, window, gtkgc->context)); }
void qsWin_destroy(struct QsWin *win) { QS_ASSERT(win); QS_ASSERT(win->win); QS_ASSERT(win->da); QS_ASSERT(qsApp); while(win->drawSyncs) { #ifdef QS_DEBUG void *ds; ds = win->drawSyncs->data; #endif qsController_destroy((struct QsController*) win->drawSyncs->data); /* this should have changed the list */ QS_ASSERT(!win->drawSyncs || win->drawSyncs->data != ds); } if(win->hashTable) g_hash_table_destroy(win->hashTable); if(win->gc) XFreeGC(gdk_x11_get_default_xdisplay(), win->gc); if(win->pixmap && win->pixmap != (intptr_t) 1) XFreePixmap(win->dsp, win->pixmap); if(win->fadeSurface) g_free(win->fadeSurface); if(win->points) g_free(win->points); if(win->unitsXLabel) g_free(win->unitsXLabel); if(win->unitsYLabel) g_free(win->unitsYLabel); while(win->traces) { #ifdef QS_DEBUG void *trace; trace = win->traces->data; #endif qsTrace_destroy((struct QsTrace *) win->traces->data); /* this should have changed the list */ QS_ASSERT(!win->traces || win->traces->data != trace); } qsApp->wins = g_slist_remove(qsApp->wins, win); gtk_widget_destroy(win->win); _qsWidget_destroy(win->adjsWidget); // Call the base destroy if we are not calling // it already. _qsAdjusterList_checkBaseDestroy(win); }
//================================================================ void* GLB_Create () { //================================================================ /// GLB_Create create opengl-window (used by GUI_gl__) GtkWidget *area; int xscreen, i1; GdkScreen *screen; GdkVisual *visual; Window root; XVisualInfo *xvisual; Colormap xcolormap; int attributes[] = { GLX_RGBA, GLX_RED_SIZE, 1, GLX_GREEN_SIZE, 1, GLX_BLUE_SIZE, 1, GLX_DOUBLEBUFFER, True, GLX_DEPTH_SIZE, 24, None }; GLB_x_id = 0; // reset area = gtk_drawing_area_new (); gtk_widget_set_double_buffered (area, FALSE); GLB_display = gdk_x11_get_default_xdisplay (); xscreen = DefaultScreen (GLB_display); screen = gdk_screen_get_default (); // printf(" screenNr = %d\n",gdk_screen_get_number(screen)); xvisual = glXChooseVisual (GLB_display, xscreen, attributes); // printf(" xvisualid=%d\n",xvisual->visualid); visual = gdk_x11_screen_lookup_visual (screen, xvisual->visualid); root = RootWindow (GLB_display, xscreen); xcolormap = XCreateColormap (GLB_display, root, xvisual->visual, AllocNone); glXGetConfig (GLB_display, xvisual, GLX_RED_SIZE, &i1); printf(" GLX_RED_SIZE=%d\n",i1); glXGetConfig (GLB_display, xvisual, GLX_DEPTH_SIZE, &i1); printf(" GLX_DEPTH_SIZE=%d\n",i1); // Gtk2 only: //colormap = gdk_x11_colormap_foreign_new (visual, xcolormap); //gtk_widget_set_colormap (area, colormap); GLB_x_context = glXCreateContext (GLB_display, xvisual, NULL, TRUE); // free (xvisual); glXWaitX(); glXWaitGL(); return area; }
void safe_window_move_resize(GdkWindow* wrapper, int x, int y, int w, int h) { XSelectInput(gdk_x11_get_default_xdisplay(), GDK_WINDOW_XID(wrapper), ExposureMask | VisibilityChangeMask | EnterWindowMask | LeaveWindowMask); gdk_window_move_resize(wrapper, x, y, w, h); GdkWindow* icon = g_object_get_data(G_OBJECT(wrapper), "wrapper_child"); if (icon) { gdk_window_resize(icon, w, h); } gdk_window_set_events(wrapper, GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_VISIBILITY_NOTIFY_MASK); }
void doppelganger_show (Doppelganger *dg) { #if 0 XChangeActivePointerGrab (gdk_x11_get_default_xdisplay (), 0, gdk_x11_cursor_get_xcursor (dg->cursor), CurrentTime); #endif }
/** * gdk_gl_query_extension: * * Indicates whether the window system supports the OpenGL extension * (GLX, WGL, etc.). * * Return value: TRUE if OpenGL is supported, FALSE otherwise. **/ gboolean gdk_gl_query_extension (void) { #ifdef GDKGLEXT_MULTIHEAD_SUPPORT return glXQueryExtension (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), NULL, NULL); #else /* GDKGLEXT_MULTIHEAD_SUPPORT */ return glXQueryExtension (gdk_x11_get_default_xdisplay (), NULL, NULL); #endif /* GDKGLEXT_MULTIHEAD_SUPPORT */ }