void
S9xOpenGLDisplayDriver::swap_control (int enable)
{
glSwapIntervalProc glSwapInterval = NULL;
const char *ext_str;
ext_str = glXQueryExtensionsString (GDK_DISPLAY (),
GDK_SCREEN_XNUMBER (
gdk_screen_get_default ()));
/* We try to set this with both extensions since some cards pretend
* to support both, but ignore one. */
if (strstr (ext_str, "GLX_MESA_swap_control"))
{
glSwapInterval = (glSwapIntervalProc)
glGetProcAddress ((GLubyte *) "glXSwapIntervalMESA");
if (glSwapInterval)
glSwapInterval (enable ? 1 : 0);
}
else if (strstr (ext_str, "GLX_SGI_swap_control"))
{
glSwapInterval = (glSwapIntervalProc)
glGetProcAddress ((GLubyte *) "glXSwapIntervalSGI");
if (glSwapInterval)
{
glSwapInterval (enable ? 1 : 0);
}
}
return;
}
static int
get_current_desktop (GdkScreen *screen)
{
Display *display;
Window win;
Atom current_desktop, type;
int format;
unsigned long n_items, bytes_after;
unsigned char *data_return = NULL;
int workspace = 0;
display = GDK_DISPLAY_XDISPLAY (gdk_screen_get_display (screen));
win = XRootWindow (display, GDK_SCREEN_XNUMBER (screen));
current_desktop = XInternAtom (display, "_NET_CURRENT_DESKTOP", True);
XGetWindowProperty (display,
win,
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)
workspace = (int) data_return[0];
if (data_return)
XFree (data_return);
return workspace;
}
static gboolean
gdk_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;
}
bool VideoOverlay::getDescription( VideoDescription &desc ) {
#ifdef _WIN32
desc = NULL;
#else
desc.display = GDK_WINDOW_XDISPLAY(gtk_widget_get_window(_window));
desc.screenID = GDK_SCREEN_XNUMBER(gtk_widget_get_screen(GTK_WIDGET(_window)));
desc.winID = GDK_WINDOW_XID(gtk_widget_get_window(_window));
#endif
return true;
}
static GdkNativeWindow select_window(GdkScreen *screen) {
Display *x_dpy;
Cursor x_cursor;
XEvent x_event;
Window x_win = None;
Window x_root;
gint x_scr;
gint status;
gint buttons = 0;
x_dpy = GDK_SCREEN_XDISPLAY (screen);
x_scr = GDK_SCREEN_XNUMBER (screen);
x_root = RootWindow (x_dpy, x_scr);
x_cursor = XCreateFontCursor (x_dpy, GDK_CROSSHAIR);
status = XGrabPointer (x_dpy, x_root, False,
MASK, GrabModeSync, GrabModeAsync,
x_root, x_cursor, CurrentTime);
if (status != GrabSuccess) {
printf("!GrabSucces\n");
return 0;
}
while ( (x_win == None) || (buttons != 0))
{
XAllowEvents (x_dpy, SyncPointer, CurrentTime);
XWindowEvent (x_dpy, x_root, MASK, &x_event);
switch (x_event.type)
{
case ButtonPress:
if (x_win == None)
{
x_win = x_event.xbutton.subwindow;
if (x_win == None)
x_win = x_root;
}
buttons++;
break;
case ButtonRelease:
if (buttons > 0)
buttons--;
break;
}
}
XUngrabPointer (x_dpy, CurrentTime);
XFreeCursor (x_dpy, x_cursor);
return x_win;
}
/* This function queries the _XROOTPMAP_ID property from the root window
* to determine the current root window background pixmap and returns a
* surface to draw directly to it.
* If _XROOTPMAP_ID is not set, then NULL returned.
*/
static cairo_surface_t *
get_root_pixmap_id_surface (GdkDisplay *display)
{
GdkScreen *screen;
Display *xdisplay;
Visual *xvisual;
Window xroot;
Atom type;
int format, result;
unsigned long nitems, bytes_after;
unsigned char *data;
cairo_surface_t *surface = NULL;
g_return_val_if_fail (display != NULL, NULL);
screen = gdk_display_get_default_screen (display);
xdisplay = GDK_DISPLAY_XDISPLAY (display);
xvisual = GDK_VISUAL_XVISUAL (gdk_screen_get_system_visual (screen));
xroot = RootWindow (xdisplay, GDK_SCREEN_XNUMBER (screen));
result = XGetWindowProperty (xdisplay, xroot,
gdk_x11_get_xatom_by_name ("_XROOTPMAP_ID"),
0L, 1L, False, XA_PIXMAP,
&type, &format, &nitems, &bytes_after,
&data);
if (result != Success || type != XA_PIXMAP ||
format != 32 || nitems != 1) {
XFree (data);
data = NULL;
}
if (data != NULL) {
Pixmap pixmap = *(Pixmap *) data;
Window root_ret;
int x_ret, y_ret;
unsigned int w_ret, h_ret, bw_ret, depth_ret;
gdk_x11_display_error_trap_push (display);
if (XGetGeometry (xdisplay, pixmap, &root_ret,
&x_ret, &y_ret, &w_ret, &h_ret,
&bw_ret, &depth_ret))
{
surface = cairo_xlib_surface_create (xdisplay,
pixmap, xvisual,
w_ret, h_ret);
}
gdk_x11_display_error_trap_pop_ignored (display);
XFree (data);
}
gdk_display_flush (display);
return surface;
}
gboolean
gdk_gl_window_make_context_current (GdkGLDrawable *draw, GdkGLContext *glcontext)
{
GdkGLDrawable *read = draw;
GdkGLConfig *glconfig;
Window glxwindow;
GLXContext glxcontext;
g_return_val_if_fail (GDK_IS_GL_WINDOW (draw), FALSE);
g_return_val_if_fail (GDK_IS_GL_CONTEXT_IMPL_X11 (glcontext), FALSE);
glconfig = GDK_GL_WINDOW (draw)->glconfig;
glxwindow = GDK_GL_WINDOW (draw)->glxwindow;
glxcontext = GDK_GL_CONTEXT_GLXCONTEXT (glcontext);
if (glxwindow == None || glxcontext == NULL)
return FALSE;
GDK_GL_NOTE (MISC, g_message (" -- Window: screen number = %d", GDK_SCREEN_XNUMBER (gdk_drawable_get_screen (GDK_DRAWABLE (draw)))));
GDK_GL_NOTE (MISC, g_message (" -- Window: 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), glxwindow, glxcontext))
{
g_warning ("glXMakeCurrent() failed");
_gdk_gl_context_set_gl_drawable (glcontext, NULL);
return FALSE;
}
_gdk_gl_context_set_gl_drawable (glcontext, draw);
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;
}
void glyph_cache_set_font(TGlyphCache *cache, PangoFontDescription *font_desc)
{
PangoFontMap *font_map;
PangoFontMetrics *metrics;
if (cache->hash) {
g_hash_table_destroy(cache->hash);
g_object_unref(cache->font_set);
}
cache->hash = g_hash_table_new_full(NULL, NULL, NULL, glyph_destroy_gfi);
font_map = pango_xft_get_font_map(
GDK_DISPLAY_XDISPLAY(cache->display),
GDK_SCREEN_XNUMBER(cache->screen)
);
g_object_ref (font_map);
cache->font_set = pango_font_map_load_fontset(
font_map,
cache->context,
font_desc,
cache->lang
);
g_object_unref(font_map);
font_map = NULL;
metrics = pango_fontset_get_metrics(cache->font_set);
pango_font_metrics_ref(metrics);
cache->ascent = pango_font_metrics_get_ascent(metrics);
cache->descent = pango_font_metrics_get_descent(metrics);
cache->width = pango_font_metrics_get_approximate_digit_width(metrics);
cache->height = cache->ascent + cache->descent;
if (cache->width <= 0) {
fprintf (stderr, "Warning: cache->width = %d\n", cache->width);
cache->width = cache->height / 2;
}
pango_font_metrics_unref(metrics);
}
static void
gtku_gl_drawing_area_init (GtkuGLDrawingArea * self)
{
GtkuGLDrawingAreaPrivate * priv = GTKU_GL_DRAWING_AREA_GET_PRIVATE (self);
gtk_widget_set_double_buffered (GTK_WIDGET (self), FALSE);
priv->dpy = NULL;
priv->visual = NULL;
priv->context = NULL;
#ifdef USE_VBLANK
priv->vblank_watch = 0;
priv->pipe[0] = -1;
priv->thread = 0;
priv->quit_thread = 0;
priv->swap_requested = 0;
#endif
XVisualInfo * vinfo = glXChooseVisual (GDK_DISPLAY (),
GDK_SCREEN_XNUMBER (gdk_screen_get_default ()),
attr_list);
if (!vinfo) {
fprintf (stderr, "Preferred visual not found, using default...\n");
return;
}
VisualID desired_id = vinfo->visualid;
XFree (vinfo);
GList * visuals = gdk_list_visuals ();
GList * vis;
for (vis = visuals; vis; vis = vis->next) {
Visual * xv = GDK_VISUAL_XVISUAL (vis->data);
if (XVisualIDFromVisual (xv) == desired_id) {
GdkColormap * colormap = gdk_colormap_new (vis->data, FALSE);
gtk_widget_set_colormap (GTK_WIDGET (self), colormap);
g_object_unref (G_OBJECT (colormap));
break;
}
}
g_list_free (visuals);
}
static gboolean
get_work_area (NotifyStack *stack,
GdkRectangle *rect)
{
Atom workarea;
Atom type;
Window win;
int format;
gulong num;
gulong leftovers;
gulong max_len = 4 * 32;
guchar *ret_workarea;
long *workareas;
int result;
int disp_screen;
#if GTK_CHECK_VERSION(3, 0, 0)
workarea = XInternAtom(GDK_DISPLAY_XDISPLAY(gdk_display_get_default()), "_NET_WORKAREA", True);
#else
workarea = XInternAtom(GDK_DISPLAY(), "_NET_WORKAREA", True);
#endif
disp_screen = GDK_SCREEN_XNUMBER (stack->screen);
/* Defaults in case of error */
rect->x = 0;
rect->y = 0;
rect->width = gdk_screen_get_width (stack->screen);
rect->height = gdk_screen_get_height (stack->screen);
if (workarea == None)
return FALSE;
#if GTK_CHECK_VERSION(3, 0, 0)
win = XRootWindow(GDK_DISPLAY_XDISPLAY(gdk_display_get_default()), disp_screen);
result = XGetWindowProperty(GDK_DISPLAY_XDISPLAY(gdk_display_get_default()),
win,
workarea,
0,
max_len,
False,
AnyPropertyType,
&type,
&format,
&num,
&leftovers,
&ret_workarea);
#else
win = XRootWindow(GDK_DISPLAY(), disp_screen);
result = XGetWindowProperty(GDK_DISPLAY(),
win,
workarea,
0,
max_len,
False,
AnyPropertyType,
&type,
&format,
&num,
&leftovers,
&ret_workarea);
#endif
if (result != Success
|| type == None
|| format == 0
|| leftovers
|| num % 4) {
return FALSE;
}
workareas = (long *) ret_workarea;
rect->x = workareas[disp_screen * 4];
rect->y = workareas[disp_screen * 4 + 1];
rect->width = workareas[disp_screen * 4 + 2];
rect->height = workareas[disp_screen * 4 + 3];
XFree (ret_workarea);
return TRUE;
}
static GdkNativeWindow
select_window_x11 (GdkScreen *screen)
{
Display *x_dpy = GDK_SCREEN_XDISPLAY (screen);
gint x_scr = GDK_SCREEN_XNUMBER (screen);
Window x_root = RootWindow (x_dpy, x_scr);
Window x_win = None;
GC x_gc = None;
Cursor x_cursor = XCreateFontCursor (x_dpy, GDK_CROSSHAIR);
GdkKeymapKey *keys = NULL;
gint status;
gint i, num_keys;
gint buttons = 0;
gint mask = ButtonPressMask | ButtonReleaseMask;
gboolean cancel = FALSE;
if (shootvals.shoot_type == SHOOT_REGION)
mask |= PointerMotionMask;
status = XGrabPointer (x_dpy, x_root, False,
mask, GrabModeSync, GrabModeAsync,
x_root, x_cursor, CurrentTime);
if (status != GrabSuccess)
{
gint x, y;
guint xmask;
/* if we can't grab the pointer, return the window under the pointer */
XQueryPointer (x_dpy, x_root, &x_root, &x_win, &x, &y, &x, &y, &xmask);
if (x_win == None || x_win == x_root)
g_message (_("Error selecting the window"));
}
if (shootvals.shoot_type == SHOOT_REGION)
{
XGCValues gc_values;
gc_values.function = GXxor;
gc_values.plane_mask = AllPlanes;
gc_values.foreground = WhitePixel (x_dpy, x_scr);
gc_values.background = BlackPixel (x_dpy, x_scr);
gc_values.line_width = 0;
gc_values.line_style = LineSolid;
gc_values.fill_style = FillSolid;
gc_values.cap_style = CapButt;
gc_values.join_style = JoinMiter;
gc_values.graphics_exposures = FALSE;
gc_values.clip_x_origin = 0;
gc_values.clip_y_origin = 0;
gc_values.clip_mask = None;
gc_values.subwindow_mode = IncludeInferiors;
x_gc = XCreateGC (x_dpy, x_root,
GCFunction | GCPlaneMask | GCForeground | GCLineWidth |
GCLineStyle | GCCapStyle | GCJoinStyle |
GCGraphicsExposures | GCBackground | GCFillStyle |
GCClipXOrigin | GCClipYOrigin | GCClipMask |
GCSubwindowMode,
&gc_values);
}
if (gdk_keymap_get_entries_for_keyval (NULL, GDK_Escape, &keys, &num_keys))
{
gdk_error_trap_push ();
#define X_GRAB_KEY(index, modifiers) \
XGrabKey (x_dpy, keys[index].keycode, modifiers, x_root, False, \
GrabModeAsync, GrabModeAsync)
for (i = 0; i < num_keys; i++)
{
X_GRAB_KEY (i, 0);
X_GRAB_KEY (i, LockMask); /* CapsLock */
X_GRAB_KEY (i, Mod2Mask); /* NumLock */
X_GRAB_KEY (i, Mod5Mask); /* ScrollLock */
X_GRAB_KEY (i, LockMask | Mod2Mask); /* CapsLock + NumLock */
X_GRAB_KEY (i, LockMask | Mod5Mask); /* CapsLock + ScrollLock */
X_GRAB_KEY (i, Mod2Mask | Mod5Mask); /* NumLock + ScrollLock */
X_GRAB_KEY (i, LockMask | Mod2Mask | Mod5Mask); /* all */
}
#undef X_GRAB_KEY
gdk_flush ();
gdk_error_trap_pop ();
}
while (! cancel && ((x_win == None) || (buttons != 0)))
{
XEvent x_event;
gint x, y, w, h;
XAllowEvents (x_dpy, SyncPointer, CurrentTime);
XWindowEvent (x_dpy, x_root, mask | KeyPressMask, &x_event);
switch (x_event.type)
{
case ButtonPress:
if (x_win == None)
{
x_win = x_event.xbutton.subwindow;
if (x_win == None)
x_win = x_root;
#ifdef HAVE_X11_XMU_WINUTIL_H
else if (! shootvals.decorate)
x_win = XmuClientWindow (x_dpy, x_win);
#endif
shootvals.x2 = shootvals.x1 = x_event.xbutton.x_root;
shootvals.y2 = shootvals.y1 = x_event.xbutton.y_root;
}
buttons++;
break;
case ButtonRelease:
if (buttons > 0)
buttons--;
if (! buttons && shootvals.shoot_type == SHOOT_REGION)
{
x = MIN (shootvals.x1, shootvals.x2);
y = MIN (shootvals.y1, shootvals.y2);
w = ABS (shootvals.x2 - shootvals.x1);
h = ABS (shootvals.y2 - shootvals.y1);
if (w > 0 && h > 0)
XDrawRectangle (x_dpy, x_root, x_gc, x, y, w, h);
shootvals.x2 = x_event.xbutton.x_root;
shootvals.y2 = x_event.xbutton.y_root;
}
break;
case MotionNotify:
if (buttons > 0)
{
x = MIN (shootvals.x1, shootvals.x2);
y = MIN (shootvals.y1, shootvals.y2);
w = ABS (shootvals.x2 - shootvals.x1);
h = ABS (shootvals.y2 - shootvals.y1);
if (w > 0 && h > 0)
XDrawRectangle (x_dpy, x_root, x_gc, x, y, w, h);
shootvals.x2 = x_event.xmotion.x_root;
shootvals.y2 = x_event.xmotion.y_root;
x = MIN (shootvals.x1, shootvals.x2);
y = MIN (shootvals.y1, shootvals.y2);
w = ABS (shootvals.x2 - shootvals.x1);
h = ABS (shootvals.y2 - shootvals.y1);
if (w > 0 && h > 0)
XDrawRectangle (x_dpy, x_root, x_gc, x, y, w, h);
}
break;
case KeyPress:
{
guint *keyvals;
gint n;
if (gdk_keymap_get_entries_for_keycode (NULL, x_event.xkey.keycode,
NULL, &keyvals, &n))
{
gint i;
for (i = 0; i < n && ! cancel; i++)
if (keyvals[i] == GDK_Escape)
cancel = TRUE;
g_free (keyvals);
}
}
break;
default:
break;
}
}
if (keys)
{
#define X_UNGRAB_KEY(index, modifiers) \
XUngrabKey (x_dpy, keys[index].keycode, modifiers, x_root)
for (i = 0; i < num_keys; i++)
{
X_UNGRAB_KEY (i, 0);
X_UNGRAB_KEY (i, LockMask); /* CapsLock */
X_UNGRAB_KEY (i, Mod2Mask); /* NumLock */
X_UNGRAB_KEY (i, Mod5Mask); /* ScrollLock */
X_UNGRAB_KEY (i, LockMask | Mod2Mask); /* CapsLock + NumLock */
X_UNGRAB_KEY (i, LockMask | Mod5Mask); /* CapsLock + ScrollLock */
X_UNGRAB_KEY (i, Mod2Mask | Mod5Mask); /* NumLock + ScrollLock */
X_UNGRAB_KEY (i, LockMask | Mod2Mask | Mod5Mask); /* all */
}
#undef X_UNGRAB_KEY
g_free (keys);
}
if (status == GrabSuccess)
XUngrabPointer (x_dpy, CurrentTime);
XFreeCursor (x_dpy, x_cursor);
if (x_gc != None)
XFreeGC (x_dpy, x_gc);
return x_win;
}
static void widget_realized (void)
{
GdkWindow * window = gtk_widget_get_window (s_widget);
#ifdef GDK_WINDOWING_X11
GdkScreen * screen = gdk_window_get_screen (window);
int nscreen = GDK_SCREEN_XNUMBER (screen);
s_display = GDK_SCREEN_XDISPLAY (screen);
s_xwindow = GDK_WINDOW_XID (window);
/* Create s_context */
int attribs[] = {
GLX_RGBA,
GLX_RED_SIZE, 1,
GLX_GREEN_SIZE, 1,
GLX_BLUE_SIZE, 1,
GLX_ALPHA_SIZE, 1,
GLX_DOUBLEBUFFER,
GLX_DEPTH_SIZE, 1,
None
};
XVisualInfo * xvinfo = glXChooseVisual (s_display, nscreen, attribs);
g_return_if_fail (xvinfo);
/* Fix up visual/colormap */
GdkVisual * visual = gdk_x11_screen_lookup_visual (screen, xvinfo->visualid);
g_return_if_fail (visual);
gtk_widget_set_visual (s_widget, visual);
s_context = glXCreateContext (s_display, xvinfo, 0, True);
g_return_if_fail (s_context);
XFree (xvinfo);
glXMakeCurrent (s_display, s_xwindow, s_context);
#endif
#ifdef GDK_WINDOWING_WIN32
s_hwnd = GDK_WINDOW_HWND (window);
s_hdc = GetDC (s_hwnd);
PIXELFORMATDESCRIPTOR desc = {
sizeof (PIXELFORMATDESCRIPTOR),
1, // version number (?)
PFD_DRAW_TO_WINDOW | // format must support window
PFD_SUPPORT_OPENGL | // format must support OpenGL
PFD_DOUBLEBUFFER, // must support double buffering
PFD_TYPE_RGBA, // request an RGBA format
24, // select a 8:8:8 bit color depth
0, 0, 0, 0, 0, 0, // color bits ignored (?)
0, // no alpha buffer
0, // shift bit ignored (?)
0, // no accumulation buffer
0, 0, 0, 0, // accumulation bits ignored (?)
16, // 16-bit z-buffer (depth buffer)
0, // no stencil buffer
0, // no auxiliary buffer (?)
PFD_MAIN_PLANE, // main drawing layer
0, // reserved (?)
0, 0, 0 // layer masks ignored (?)
};
int format = ChoosePixelFormat (s_hdc, & desc);
g_return_if_fail (format != 0);
SetPixelFormat (s_hdc, format, & desc);
s_glrc = wglCreateContext (s_hdc);
g_return_if_fail (s_glrc);
wglMakeCurrent (s_hdc, s_glrc);
#endif
}
static GdkNativeWindow
select_window (GdkScreen *screen)
{
#define MASK (ButtonPressMask | ButtonReleaseMask)
Display *x_dpy;
Cursor x_cursor;
XEvent x_event;
Window x_win;
Window x_root;
gint x_scr;
gint status;
gint buttons;
x_dpy = GDK_SCREEN_XDISPLAY (screen);
x_scr = GDK_SCREEN_XNUMBER (screen);
x_win = None;
x_root = RootWindow (x_dpy, x_scr);
x_cursor = XCreateFontCursor (x_dpy, GDK_CROSSHAIR);
buttons = 0;
status = XGrabPointer (x_dpy, x_root, False,
MASK, GrabModeSync, GrabModeAsync,
x_root, x_cursor, CurrentTime);
if (status != GrabSuccess)
{
g_message (_("Error grabbing the pointer %d"), status);
return 0;
}
while ((x_win == None) || (buttons != 0))
{
XAllowEvents (x_dpy, SyncPointer, CurrentTime);
XWindowEvent (x_dpy, x_root, MASK, &x_event);
switch (x_event.type)
{
case ButtonPress:
if (x_win == None)
{
x_win = x_event.xbutton.subwindow;
if (x_win == None)
x_win = x_root;
}
buttons++;
break;
case ButtonRelease:
if (buttons > 0)
buttons--;
break;
default:
g_assert_not_reached ();
}
}
XUngrabPointer (x_dpy, CurrentTime);
XFreeCursor (x_dpy, x_cursor);
return x_win;
}
static void
init_xft_settings (GdkScreen *screen)
{
GdkScreenX11 *screen_x11 = GDK_SCREEN_X11 (screen);
Display *xdisplay = GDK_SCREEN_XDISPLAY (screen);
int xscreen = GDK_SCREEN_XNUMBER (screen);
double dpi_double;
if (screen_x11->xft_init)
return;
screen_x11->xft_init = TRUE;
if (!get_boolean_default (xdisplay, "antialias", &screen_x11->xft_antialias))
screen_x11->xft_antialias = TRUE;
if (!get_boolean_default (xdisplay, "hinting", &screen_x11->xft_hinting))
screen_x11->xft_hinting = TRUE;
if (!get_integer_default (xdisplay, "hintstyle", &screen_x11->xft_hintstyle))
screen_x11->xft_hintstyle = FC_HINT_FULL;
if (!get_integer_default (xdisplay, "rgba", &screen_x11->xft_rgba))
{
int subpixel = FC_RGBA_UNKNOWN;
#if RENDER_MAJOR > 0 || RENDER_MINOR >= 6
if (_gdk_x11_have_render (screen_x11->display))
{
int render_order = XRenderQuerySubpixelOrder (xdisplay, xscreen);
switch (render_order)
{
default:
case SubPixelUnknown:
subpixel = FC_RGBA_UNKNOWN;
break;
case SubPixelHorizontalRGB:
subpixel = FC_RGBA_RGB;
break;
case SubPixelHorizontalBGR:
subpixel = FC_RGBA_BGR;
break;
case SubPixelVerticalRGB:
subpixel = FC_RGBA_VRGB;
break;
case SubPixelVerticalBGR:
subpixel = FC_RGBA_VBGR;
break;
case SubPixelNone:
subpixel = FC_RGBA_NONE;
break;
}
}
#endif
screen_x11->xft_rgba = subpixel;
}
if (!get_double_default (xdisplay, "dpi", &dpi_double))
dpi_double = (((double) DisplayHeight (xdisplay, xscreen) * 25.4) /
(double) DisplayHeightMM (xdisplay, xscreen));
screen_x11->xft_dpi = (int)(0.5 + PANGO_SCALE * dpi_double);
}
static void
gtku_gl_drawing_area_realize (GtkWidget * widget)
{
GtkuGLDrawingArea * self = GTKU_GL_DRAWING_AREA (widget);
GtkuGLDrawingAreaPrivate * priv = GTKU_GL_DRAWING_AREA_GET_PRIVATE (self);
/* chain up */
GTK_WIDGET_CLASS (gtku_gl_drawing_area_parent_class)->realize (widget);
priv->dpy = GDK_WINDOW_XDISPLAY(widget->window);
#if 0
priv->visual = glXChooseVisual (priv->dpy,
GDK_SCREEN_XNUMBER (gdk_drawable_get_screen (GDK_DRAWABLE (widget->window))),
//DefaultScreen (priv->dpy),
attr_list);
#endif
GdkDrawable * draw = GDK_DRAWABLE (widget->window);
int screen = GDK_SCREEN_XNUMBER (gdk_drawable_get_screen (draw));
XVisualInfo vinfo_template = {
.visualid = XVisualIDFromVisual (gdk_x11_visual_get_xvisual (
gdk_drawable_get_visual (draw))),
.screen = screen,
.depth = gdk_drawable_get_depth (draw),
};
int nitems;
fprintf (stderr, "Using X Visual 0x%x\n",
(unsigned int) vinfo_template.visualid);
priv->visual = XGetVisualInfo (priv->dpy,
VisualIDMask | VisualScreenMask | VisualDepthMask,
&vinfo_template, &nitems);
if (priv->visual == NULL) {
g_warning ("Failed to find GLX visual\n");
return;
}
if (nitems != 1)
fprintf (stderr, "Warning: more than one matching X visual found\n");
priv->context = glXCreateContext (priv->dpy, priv->visual, 0,
GL_TRUE);
if (!priv->context) {
g_warning ("Failed to get GLX context\n");
XFree (priv->visual);
priv->visual = NULL;
return;
}
if (!glXMakeCurrent (priv->dpy, GDK_WINDOW_XID (widget->window),
priv->context)) {
g_warning ("Could not make GLX context current\n");
return;
}
/* If the user doesn't want vblank sync, we are done */
if (!self->vblank_sync)
return;
/* Check for the presence of the video_sync extension */
if (!is_glx_extension_present (priv->dpy, screen, "GLX_SGI_video_sync")) {
self->vblank_sync = 0;
fprintf (stderr, "Video sync functions not found, disabling...\n");
return;
}
#ifdef USE_VBLANK
/* Below we create a new thread to monitor the vblank. We will
* signal back to this thread by writing to a file descriptor
* when each vblank occurs. */
/* TODO: check extension list */
GetVideoSyncSGI = (PFNGLXGETVIDEOSYNCSGIPROC) glXGetProcAddressARB (
(unsigned char *)"glXGetVideoSyncSGI");
WaitVideoSyncSGI = (PFNGLXWAITVIDEOSYNCSGIPROC) glXGetProcAddressARB (
(unsigned char *)"glXWaitVideoSyncSGI");
if (!GetVideoSyncSGI || !WaitVideoSyncSGI) {
self->vblank_sync = 0;
fprintf (stderr, "Video sync functions not found, disabling...\n");
return;
}
unsigned int count = 0;
if (GetVideoSyncSGI (&count) != 0) {
self->vblank_sync = 0;
fprintf (stderr, "Video sync counter failed, disabling...\n");
return;
}
int pp = pipe (priv->pipe);
assert (pp >= 0);
fcntl (priv->pipe[0], F_SETFL, O_NONBLOCK);
if (pthread_create (&priv->thread, NULL, swap_thread, priv) != 0) {
self->vblank_sync = 0;
fprintf (stderr, "Video sync thread creation failed, disabling...\n");
return;
}
GIOChannel * chan = g_io_channel_unix_new (priv->pipe[0]);
priv->vblank_watch = g_io_add_watch (chan, G_IO_IN, swap_func, self);
g_io_channel_unref (chan);
#endif
}
static void
get_work_area (GdkScreen *screen,
GdkRectangle *area)
{
Atom workarea;
Atom type;
Window win;
int format;
gulong num;
gulong leftovers;
gulong max_len = 4 * 32;
guchar *ret_workarea;
long *workareas;
int result;
int disp_screen;
int desktop;
Display *display;
display = GDK_DISPLAY_XDISPLAY (gdk_screen_get_display (screen));
disp_screen = GDK_SCREEN_XNUMBER (screen);
workarea = XInternAtom (display, "_NET_WORKAREA", True);
/* Defaults in case of error */
area->x = 0;
area->y = 0;
area->width = gdk_screen_get_width (screen);
area->height = gdk_screen_get_height (screen);
if (workarea == None)
return;
win = XRootWindow (display, disp_screen);
result = XGetWindowProperty (display,
win,
workarea,
0,
max_len,
False,
AnyPropertyType,
&type,
&format,
&num,
&leftovers,
&ret_workarea);
if (result != Success ||
type == None ||
format == 0 ||
leftovers ||
num % 4 != 0)
return;
desktop = get_current_desktop (screen);
workareas = (long *) ret_workarea;
area->x = workareas[desktop * 4];
area->y = workareas[desktop * 4 + 1];
area->width = workareas[desktop * 4 + 2];
area->height = workareas[desktop * 4 + 3];
XFree (ret_workarea);
}
static gboolean
get_work_area (MateRRLabeler *labeler,
GdkRectangle *rect)
{
Atom workarea;
Atom type;
Window win;
int format;
gulong num;
gulong leftovers;
gulong max_len = 4 * 32;
guchar *ret_workarea;
long *workareas;
int result;
int disp_screen;
int desktop;
Display *display;
display = GDK_DISPLAY_XDISPLAY (gdk_screen_get_display (labeler->priv->screen));
workarea = XInternAtom (display, "_NET_WORKAREA", True);
disp_screen = GDK_SCREEN_XNUMBER (labeler->priv->screen);
/* Defaults in case of error */
rect->x = 0;
rect->y = 0;
rect->width = gdk_screen_get_width (labeler->priv->screen);
rect->height = gdk_screen_get_height (labeler->priv->screen);
if (workarea == None)
return FALSE;
win = XRootWindow (display, disp_screen);
result = XGetWindowProperty (display,
win,
workarea,
0,
max_len,
False,
AnyPropertyType,
&type,
&format,
&num,
&leftovers,
&ret_workarea);
if (result != Success
|| type == None
|| format == 0
|| leftovers
|| num % 4) {
return FALSE;
}
desktop = get_current_desktop (labeler->priv->screen);
workareas = (long *) ret_workarea;
rect->x = workareas[desktop * 4];
rect->y = workareas[desktop * 4 + 1];
rect->width = workareas[desktop * 4 + 2];
rect->height = workareas[desktop * 4 + 3];
XFree (ret_workarea);
return TRUE;
}
void
gdk_x11_screen_get_work_area (GdkScreen *screen,
GdkRectangle *area)
{
GdkX11Screen *x11_screen = GDK_X11_SCREEN (screen);
Atom workarea;
Atom type;
Window win;
int format;
gulong num;
gulong leftovers;
gulong max_len = 4 * 32;
guchar *ret_workarea = NULL;
long *workareas;
int result;
int disp_screen;
int desktop;
Display *display;
display = GDK_DISPLAY_XDISPLAY (gdk_screen_get_display (screen));
disp_screen = GDK_SCREEN_XNUMBER (screen);
workarea = XInternAtom (display, "_NET_WORKAREA", True);
/* Defaults in case of error */
area->x = 0;
area->y = 0;
area->width = gdk_screen_get_width (screen);
area->height = gdk_screen_get_height (screen);
if (!gdk_x11_screen_supports_net_wm_hint (screen,
gdk_atom_intern_static_string ("_NET_WORKAREA")))
return;
if (workarea == None)
return;
win = XRootWindow (display, disp_screen);
result = XGetWindowProperty (display,
win,
workarea,
0,
max_len,
False,
AnyPropertyType,
&type,
&format,
&num,
&leftovers,
&ret_workarea);
if (result != Success ||
type == None ||
format == 0 ||
leftovers ||
num % 4 != 0)
goto out;
desktop = get_current_desktop (screen);
if (desktop + 1 > num / 4) /* fvwm gets this wrong */
goto out;
workareas = (long *) ret_workarea;
area->x = workareas[desktop * 4];
area->y = workareas[desktop * 4 + 1];
area->width = workareas[desktop * 4 + 2];
area->height = workareas[desktop * 4 + 3];
area->x /= x11_screen->window_scale;
area->y /= x11_screen->window_scale;
area->width /= x11_screen->window_scale;
area->height /= x11_screen->window_scale;
out:
if (ret_workarea)
XFree (ret_workarea);
}
static __SOVPropArray *
gdk_gl_overlay_get_sov_props (GdkScreen *screen)
{
__SOVPropArray *sov_props;
GdkWindow *root_window;
#ifdef GDKGLEXT_MULTIHEAD_SUPPORT
GdkDisplay *display;
#endif /* GDKGLEXT_MULTIHEAD_SUPPORT */
Display *xdisplay;
Atom xa_sov;
Status status;
Atom actual_type;
int actual_format;
unsigned long nitems, bytes_after;
unsigned char *prop = NULL;
GDK_GL_NOTE_FUNC_PRIVATE ();
#ifdef GDKGLEXT_MULTIHEAD_SUPPORT
root_window = gdk_screen_get_root_window (screen);
#else /* GDKGLEXT_MULTIHEAD_SUPPORT */
root_window = gdk_get_default_root_window ();
#endif /* GDKGLEXT_MULTIHEAD_SUPPORT */
if (quark_sov_props == 0)
quark_sov_props = g_quark_from_static_string (quark_sov_props_string);
sov_props = g_object_get_qdata (G_OBJECT (root_window), quark_sov_props);
if (sov_props != NULL)
return sov_props;
sov_props = g_malloc (sizeof (__SOVPropArray));
#ifdef GDKGLEXT_MULTIHEAD_SUPPORT
display = gdk_screen_get_display (screen);
xdisplay = GDK_DISPLAY_XDISPLAY (display);
xa_sov = gdk_x11_get_xatom_by_name_for_display (display, "SERVER_OVERLAY_VISUALS");
#else /* GDKGLEXT_MULTIHEAD_SUPPORT */
xdisplay = gdk_x11_get_default_xdisplay ();
xa_sov = gdk_x11_get_xatom_by_name ("SERVER_OVERLAY_VISUALS");
#endif /* GDKGLEXT_MULTIHEAD_SUPPORT */
status = XGetWindowProperty (xdisplay, GDK_WINDOW_XWINDOW (root_window),
xa_sov, 0L, 1000000L, False, AnyPropertyType,
&actual_type, &actual_format,
&nitems, &bytes_after, &prop);
if (status != Success ||
actual_type == None ||
actual_format != 32 ||
nitems < 4)
{
GDK_GL_NOTE (MISC, g_message (" -- SERVER_OVERLAY_VISUALS: not supported"));
if (prop != NULL)
XFree (prop);
sov_props->prop = NULL;
sov_props->num = 0;
}
else
{
GDK_GL_NOTE (MISC, g_message (" -- SERVER_OVERLAY_VISUALS: supported"));
sov_props->prop = (__SOVProp *) prop;
sov_props->num = nitems / (sizeof (__SOVProp) / 4);
}
g_object_set_qdata_full (G_OBJECT (root_window), quark_sov_props, sov_props,
(GDestroyNotify) sov_prop_array_destroy);
#ifdef G_ENABLE_DEBUG
if (gdk_gl_debug_flags & GDK_GL_DEBUG_MISC)
{
#ifdef GDKGLEXT_MULTIHEAD_SUPPORT
int screen_num = GDK_SCREEN_XNUMBER (screen);
#else /* GDKGLEXT_MULTIHEAD_SUPPORT */
int screen_num = gdk_x11_get_default_screen ();
#endif /* GDKGLEXT_MULTIHEAD_SUPPORT */
int i;
g_message (" -- SERVER_OVERLAY_VISUALS: properties");
g_print ("screen\tvisual\ttype\tvalue\tlayer\n");
for (i = 0; i < sov_props->num; i++)
{
g_print ("%d\t0x%lx\t%lu\t%lu\t%ld\n",
screen_num,
(VisualID) (sov_props->prop[i].overlay_visual),
(CARD32) (sov_props->prop[i].transparent_type),
(CARD32) (sov_props->prop[i].value),
(INT32) (sov_props->prop[i].layer));
}
}
#endif /* G_ENABLE_DEBUG */
return sov_props;
}