static void
clutter_glx_texture_pixmap_unrealize (ClutterActor *actor)
{
ClutterGLXTexturePixmapPrivate *priv;
Display *dpy;
priv = CLUTTER_GLX_TEXTURE_PIXMAP (actor)->priv;
dpy = clutter_x11_get_default_display();
if (!_have_tex_from_pixmap_ext)
{
CLUTTER_ACTOR_CLASS (clutter_glx_texture_pixmap_parent_class)->
unrealize (actor);
return;
}
if (!CLUTTER_ACTOR_IS_REALIZED (actor))
return;
if (priv->glx_pixmap && priv->bound)
{
clutter_x11_trap_x_errors ();
(_gl_release_tex_image) (dpy,
priv->glx_pixmap,
GLX_FRONT_LEFT_EXT);
XSync (clutter_x11_get_default_display(), FALSE);
clutter_x11_untrap_x_errors ();
priv->bound = FALSE;
}
CLUTTER_ACTOR_UNSET_FLAGS (actor, CLUTTER_ACTOR_REALIZED);
}
static void
st_clipboard_init (StClipboard *self)
{
Display *dpy;
StClipboardPrivate *priv;
priv = self->priv = CLIPBOARD_PRIVATE (self);
priv->clipboard_window =
XCreateSimpleWindow (clutter_x11_get_default_display (),
clutter_x11_get_root_window (),
-1, -1, 1, 1, 0, 0, 0);
dpy = clutter_x11_get_default_display ();
/* Only create once */
if (__atom_clip == None)
__atom_clip = XInternAtom (dpy, "CLIPBOARD", 0);
if (__utf8_string == None)
__utf8_string = XInternAtom (dpy, "UTF8_STRING", 0);
if (__atom_targets == None)
__atom_targets = XInternAtom (dpy, "TARGETS", 0);
priv->n_targets = 2;
priv->supported_targets = g_new (Atom, priv->n_targets);
priv->supported_targets[0] = __utf8_string;
priv->supported_targets[1] = __atom_targets;
clutter_x11_add_filter ((ClutterX11FilterFunc) st_clipboard_provider,
self);
}
static void
clutter_glx_texture_pixmap_update_area (ClutterX11TexturePixmap *texture,
gint x,
gint y,
gint width,
gint height)
{
ClutterGLXTexturePixmapPrivate *priv;
Display *dpy;
CLUTTER_NOTE (TEXTURE, "Updating texture pixmap");
priv = CLUTTER_GLX_TEXTURE_PIXMAP (texture)->priv;
dpy = clutter_x11_get_default_display();
if (!CLUTTER_ACTOR_IS_REALIZED (texture))
return;
if (priv->use_fallback)
{
CLUTTER_NOTE (TEXTURE, "Falling back to X11");
parent_class->update_area (texture,
x, y,
width, height);
return;
}
if (priv->glx_pixmap == None)
return;
if (texture_bind (CLUTTER_GLX_TEXTURE_PIXMAP(texture)))
{
CLUTTER_NOTE (TEXTURE, "Really updating via GLX");
clutter_x11_trap_x_errors ();
(_gl_bind_tex_image) (dpy,
priv->glx_pixmap,
GLX_FRONT_LEFT_EXT,
NULL);
XSync (clutter_x11_get_default_display(), FALSE);
/* Note above fires X error for non name pixmaps - but
* things still seem to work - i.e pixmap updated
*/
if (clutter_x11_untrap_x_errors ())
CLUTTER_NOTE (TEXTURE, "Update bind_tex_image failed");
priv->bound = TRUE;
}
else
g_warning ("Failed to bind initial tex");
if (CLUTTER_ACTOR_IS_VISIBLE (CLUTTER_ACTOR(texture)))
clutter_actor_queue_redraw (CLUTTER_ACTOR(texture));
}
/**
* clutter_x11_texture_pixmap_set_window:
* @texture: the texture to bind
* @window: the X window to which the texture should be bound
* @automatic: TRUE is automatic window updates, FALSE for manual.
*
* Sets up a suitable pixmap for the window, using the composite and damage
* extensions if possible, and then calls
* clutter_x11_texture_pixmap_set_pixmap(). If you want a window in a texture,
* you probably want this function, or its older sister,
* clutter_glx_texture_pixmap_set_window().
*
* Since: 0.8
**/
void
clutter_x11_texture_pixmap_set_window (ClutterX11TexturePixmap *texture,
Window window)
{
ClutterX11TexturePixmapPrivate *priv;
XWindowAttributes attr;
Display *dpy = clutter_x11_get_default_display ();
g_return_if_fail (CLUTTER_X11_IS_TEXTURE_PIXMAP (texture));
priv = texture->priv;
if (!clutter_x11_has_composite_extension())
return;
if (priv->window == window)
return;
if (priv->window)
{
clutter_x11_remove_filter (on_x_event_filter_too, (gpointer)texture);
}
priv->window = window;
priv->window_mapped = FALSE;
priv->destroyed = FALSE;
if (window == None)
return;
clutter_x11_trap_x_errors ();
{
if (!XGetWindowAttributes (dpy, window, &attr))
{
XSync (dpy, False);
clutter_x11_untrap_x_errors ();
g_warning ("bad window 0x%x", (guint32)window);
priv->window = None;
return;
}
}
clutter_x11_untrap_x_errors ();
if (priv->window)
{
XSelectInput (dpy, priv->window,
attr.your_event_mask | StructureNotifyMask);
clutter_x11_add_filter (on_x_event_filter_too, (gpointer)texture);
}
g_object_ref (texture);
g_object_notify (G_OBJECT (texture), "window");
clutter_x11_texture_pixmap_set_mapped (texture,
attr.map_state == IsViewable);
clutter_x11_texture_pixmap_sync_window (texture);
g_object_unref (texture);
}
static ClutterX11FilterReturn
st_clipboard_provider (XEvent *xev,
ClutterEvent *cev,
StClipboard *clipboard)
{
XSelectionEvent notify_event;
XSelectionRequestEvent *req_event;
if (xev->type != SelectionRequest)
return CLUTTER_X11_FILTER_CONTINUE;
req_event = &xev->xselectionrequest;
clutter_x11_trap_x_errors ();
if (req_event->target == __atom_targets)
{
XChangeProperty (req_event->display,
req_event->requestor,
req_event->property,
XA_ATOM,
32,
PropModeReplace,
(guchar*) clipboard->priv->supported_targets,
clipboard->priv->n_targets);
}
else
{
XChangeProperty (req_event->display,
req_event->requestor,
req_event->property,
req_event->target,
8,
PropModeReplace,
(guchar*) clipboard->priv->clipboard_text,
strlen (clipboard->priv->clipboard_text));
}
notify_event.type = SelectionNotify;
notify_event.display = req_event->display;
notify_event.requestor = req_event->requestor;
notify_event.selection = req_event->selection;
notify_event.target = req_event->target;
notify_event.time = req_event->time;
if (req_event->property == None)
notify_event.property = req_event->target;
else
notify_event.property = req_event->property;
/* notify the requestor that they have a copy of the selection */
XSendEvent (req_event->display, req_event->requestor, False, 0,
(XEvent *) ¬ify_event);
/* Make it happen non async */
XSync (clutter_x11_get_default_display(), FALSE);
clutter_x11_untrap_x_errors (); /* FIXME: Warn here on fail ? */
return CLUTTER_X11_FILTER_REMOVE;
}
static gboolean
draw_arc (gpointer data)
{
Pixmap pixmap = GPOINTER_TO_UINT (data);
Display *dpy = clutter_x11_get_default_display ();
static GC gc = None;
static int x = 100, y = 100;
if (gc == None)
{
XGCValues gc_values = { 0 };
gc_values.line_width = 12;
/* This is an attempt to get a black pixel will full
opacity. Seemingly the BlackPixel macro and the default GC
value are a fully transparent color */
gc_values.foreground = 0xff000000;
gc = XCreateGC (dpy,
pixmap,
GCLineWidth | GCForeground,
&gc_values);
}
XDrawArc (dpy, pixmap, gc, x, y, 100, 100, 0, 360 * 64);
x -= 5;
y -= 5;
return G_SOURCE_CONTINUE;
}
/**
* st_clipboard_get_text:
* @clipboard: A #StCliboard
* @type: The type of clipboard data you want
* @callback: (scope async): function to be called when the text is retreived
* @user_data: data to be passed to the callback
*
* Request the data from the clipboard in text form. @callback is executed
* when the data is retreived.
*
*/
void
st_clipboard_get_text (StClipboard *clipboard,
StClipboardType type,
StClipboardCallbackFunc callback,
gpointer user_data)
{
EventFilterData *data;
Display *dpy;
g_return_if_fail (ST_IS_CLIPBOARD (clipboard));
g_return_if_fail (callback != NULL);
data = g_new0 (EventFilterData, 1);
data->clipboard = clipboard;
data->callback = callback;
data->user_data = user_data;
clutter_x11_add_filter ((ClutterX11FilterFunc) st_clipboard_x11_event_filter,
data);
dpy = clutter_x11_get_default_display ();
clutter_x11_trap_x_errors (); /* safety on */
XConvertSelection (dpy,
type == ST_CLIPBOARD_TYPE_CLIPBOARD ? __atom_clip : __atom_primary,
__utf8_string, __utf8_string,
clipboard->priv->clipboard_window,
CurrentTime);
clutter_x11_untrap_x_errors ();
}
static void
clutter_x11_texture_pixmap_dispose (GObject *object)
{
ClutterX11TexturePixmap *texture = CLUTTER_X11_TEXTURE_PIXMAP (object);
ClutterX11TexturePixmapPrivate *priv = texture->priv;
free_damage_resources (texture);
clutter_x11_remove_filter (on_x_event_filter_too, (gpointer)texture);
if (priv->owns_pixmap && priv->pixmap)
{
g_signal_emit (texture, signals[PIXMAP_FREEING], 0, NULL);
XFreePixmap (clutter_x11_get_default_display (), priv->pixmap);
priv->pixmap = None;
}
if (priv->image)
{
XDestroyImage (priv->image);
priv->image = NULL;
}
free_shm_resources (texture);
G_OBJECT_CLASS (clutter_x11_texture_pixmap_parent_class)->dispose (object);
}
/**
* st_clipboard_set_text:
* @clipboard: A #StClipboard
* @type: The type of clipboard that you want to set
* @text: text to copy to the clipboard
*
* Sets text as the current contents of the clipboard.
*/
void
st_clipboard_set_text (StClipboard *clipboard,
StClipboardType type,
const gchar *text)
{
StClipboardPrivate *priv;
Display *dpy;
g_return_if_fail (ST_IS_CLIPBOARD (clipboard));
g_return_if_fail (text != NULL);
priv = clipboard->priv;
/* make a copy of the text */
g_free (priv->clipboard_text);
priv->clipboard_text = g_strdup (text);
/* tell X we own the clipboard selection */
dpy = clutter_x11_get_default_display ();
clutter_x11_trap_x_errors ();
XSetSelectionOwner (dpy,
type == ST_CLIPBOARD_TYPE_CLIPBOARD ? __atom_clip : __atom_primary,
priv->clipboard_window,
CurrentTime);
XSync (dpy, FALSE);
clutter_x11_untrap_x_errors ();
}
static void
mpl_panel_clutter_set_size (MplPanelClient *self, guint width, guint height)
{
MplPanelClutterPrivate *priv = MPL_PANEL_CLUTTER (self)->priv;
Display *xdpy = clutter_x11_get_default_display ();
XSizeHints hints;
MplPanelClientClass *p_class;
p_class = MPL_PANEL_CLIENT_CLASS (mpl_panel_clutter_parent_class);
clutter_actor_set_size (priv->stage, width, height);
mpl_panel_clutter_ensure_window ((MplPanelClutter*)self);
hints.min_width = width;
hints.min_height = height;
hints.flags = PMinSize;
MPL_X_ERROR_TRAP ();
XSetWMNormalHints (xdpy, priv->xwindow, &hints);
XResizeWindow (xdpy, priv->xwindow, width, height);
MPL_X_ERROR_UNTRAP ();
clutter_stage_ensure_viewport (CLUTTER_STAGE (priv->stage));
if (p_class->set_size)
p_class->set_size (self, width, height);
}
static void
clutter_glx_texture_pixmap_init (ClutterGLXTexturePixmap *self)
{
ClutterGLXTexturePixmapPrivate *priv;
priv = self->priv =
G_TYPE_INSTANCE_GET_PRIVATE (self,
CLUTTER_GLX_TYPE_TEXTURE_PIXMAP,
ClutterGLXTexturePixmapPrivate);
if (_ext_check_done == FALSE)
{
const gchar *glx_extensions = NULL;
glx_extensions =
glXQueryExtensionsString (clutter_x11_get_default_display (),
clutter_x11_get_default_screen ());
/* Check for the texture from pixmap extension */
if (cogl_check_extension ("GLX_EXT_texture_from_pixmap", glx_extensions))
{
_gl_bind_tex_image =
(BindTexImage)cogl_get_proc_address ("glXBindTexImageEXT");
_gl_release_tex_image =
(ReleaseTexImage)cogl_get_proc_address ("glXReleaseTexImageEXT");
if (_gl_bind_tex_image && _gl_release_tex_image)
_have_tex_from_pixmap_ext = TRUE;
}
_ext_check_done = TRUE;
}
}
/* Class functions */
gboolean scim_bridge_client_imcontext_filter_key_event (ClutterIMContext *context, ClutterKeyEvent *event)
{
scim_bridge_pdebugln (8, "scim_bridge_client_imcontext_filter_key_event ()");
ScimBridgeClientIMContext *imcontext = SCIM_BRIDGE_CLIENT_IMCONTEXT (context);
if (scim_bridge_client_is_messenger_opened () && imcontext != NULL ) {
if (context->actor != NULL) {
ClutterActor *stage = clutter_actor_get_stage (context->actor);
Window current_window, root, parent, *childs;
unsigned int nchild;
XWindowAttributes winattr;
Display *xdpy;
int new_window_x;
int new_window_y;
clutter_actor_get_transformed_position (context->actor, &new_window_x, &new_window_y);
xdpy = clutter_x11_get_default_display ();
current_window = clutter_x11_get_stage_window(CLUTTER_STAGE(stage));
while(1) {
XGetWindowAttributes (xdpy, current_window, &winattr);
new_window_x += winattr.x;
new_window_y += winattr.y;
XQueryTree(xdpy, current_window, &root, &parent, &childs, &nchild);
current_window = parent;
if (root == parent)
break;
}
if (imcontext->window_x != new_window_x || imcontext->window_y != new_window_y) {
imcontext->window_x = new_window_x;
imcontext->window_y = new_window_y;
scim_bridge_pdebugln (1,
"The cursor location is changed: x = %d + %d\ty = %d + %d",
imcontext->window_x, imcontext->cursor_x, imcontext->window_y, imcontext->cursor_y);
if (set_cursor_location (imcontext, new_window_x, new_window_y, imcontext->cursor_x, imcontext->cursor_y)) {
scim_bridge_perrorln ("An IOException occurred at scim_bridge_client_imcontext_filter_key_event ()");
return clutter_im_context_filter_keypress (fallback_imcontext, event);
}
}
}
boolean consumed = FALSE;
if (filter_key_event (imcontext, event, &consumed)) {
scim_bridge_perrorln ("An IOException occurred at scim_bridge_client_imcontext_filter_key_event ()");
} else if (consumed) {
return TRUE;
}
}
if (imcontext == NULL || !imcontext->enabled) {
return clutter_im_context_filter_keypress (fallback_imcontext, event);
}
return FALSE;
}
static void
xfixes_cursor_reset_image (ShellXFixesCursor *xfixes_cursor)
{
XFixesCursorImage *cursor_image;
CoglHandle sprite = COGL_INVALID_HANDLE;
if (!xfixes_cursor->have_xfixes)
return;
cursor_image = XFixesGetCursorImage (clutter_x11_get_default_display ());
sprite = cogl_texture_new_from_data (cursor_image->width,
cursor_image->height,
COGL_TEXTURE_NONE,
#if G_BYTE_ORDER == G_LITTLE_ENDIAN
COGL_PIXEL_FORMAT_BGRA_8888_PRE,
#else
COGL_PIXEL_FORMAT_ARGB_8888_PRE,
#endif
COGL_PIXEL_FORMAT_ANY,
cursor_image->width * 4, /* stride */
(const guint8 *) cursor_image->pixels);
if (sprite != COGL_INVALID_HANDLE)
{
if (xfixes_cursor->cursor_sprite != NULL)
cogl_handle_unref (xfixes_cursor->cursor_sprite);
xfixes_cursor->cursor_sprite = sprite;
xfixes_cursor->cursor_hot_x = cursor_image->xhot;
xfixes_cursor->cursor_hot_y = cursor_image->yhot;
g_signal_emit (xfixes_cursor, signals[CURSOR_CHANGED], 0);
}
}
static ClutterX11FilterReturn
on_x_event_filter (XEvent *xev, ClutterEvent *cev, gpointer data)
{
ClutterX11TexturePixmap *texture;
ClutterX11TexturePixmapPrivate *priv;
Display *dpy;
texture = CLUTTER_X11_TEXTURE_PIXMAP (data);
g_return_val_if_fail (CLUTTER_X11_IS_TEXTURE_PIXMAP (texture), \
CLUTTER_X11_FILTER_CONTINUE);
dpy = clutter_x11_get_default_display();
priv = texture->priv;
if (xev->type == _damage_event_base + XDamageNotify)
{
XserverRegion parts;
gint i, r_count;
XRectangle *r_damage;
XRectangle r_bounds;
XDamageNotifyEvent *dev = (XDamageNotifyEvent*)xev;
if (dev->drawable != priv->damage_drawable)
return CLUTTER_X11_FILTER_CONTINUE;
clutter_x11_trap_x_errors ();
/*
* Retrieve the damaged region and break it down into individual
* rectangles so we do not have to update the whole shebang.
*/
parts = XFixesCreateRegion (dpy, 0, 0);
XDamageSubtract (dpy, priv->damage, None, parts);
r_damage = XFixesFetchRegionAndBounds (dpy,
parts,
&r_count,
&r_bounds);
clutter_x11_untrap_x_errors ();
if (r_damage)
{
for (i = 0; i < r_count; ++i)
clutter_x11_texture_pixmap_update_area (texture,
r_damage[i].x,
r_damage[i].y,
r_damage[i].width,
r_damage[i].height);
XFree (r_damage);
}
XFixesDestroyRegion (dpy, parts);
}
return CLUTTER_X11_FILTER_CONTINUE;
}
static void
meta_backend_x11_post_init (MetaBackend *backend)
{
MetaBackendX11 *x11 = META_BACKEND_X11 (backend);
MetaBackendX11Private *priv = meta_backend_x11_get_instance_private (x11);
int major, minor;
priv->xdisplay = clutter_x11_get_default_display ();
priv->source = x_event_source_new (backend);
if (!XSyncQueryExtension (priv->xdisplay, &priv->xsync_event_base, &priv->xsync_error_base) ||
!XSyncInitialize (priv->xdisplay, &major, &minor))
meta_fatal ("Could not initialize XSync");
{
int major = 2, minor = 3;
gboolean has_xi = FALSE;
if (XQueryExtension (priv->xdisplay,
"XInputExtension",
&priv->xinput_opcode,
&priv->xinput_error_base,
&priv->xinput_event_base))
{
if (XIQueryVersion (priv->xdisplay, &major, &minor) == Success)
{
int version = (major * 10) + minor;
if (version >= 22)
has_xi = TRUE;
}
}
if (!has_xi)
meta_fatal ("X server doesn't have the XInput extension, version 2.2 or newer\n");
}
take_touch_grab (backend);
priv->xcb = XGetXCBConnection (priv->xdisplay);
if (!xkb_x11_setup_xkb_extension (priv->xcb,
XKB_X11_MIN_MAJOR_XKB_VERSION,
XKB_X11_MIN_MINOR_XKB_VERSION,
XKB_X11_SETUP_XKB_EXTENSION_NO_FLAGS,
NULL, NULL,
&priv->xkb_event_base,
&priv->xkb_error_base))
meta_fatal ("X server doesn't have the XKB extension, version %d.%d or newer\n",
XKB_X11_MIN_MAJOR_XKB_VERSION, XKB_X11_MIN_MINOR_XKB_VERSION);
g_signal_connect_object (clutter_device_manager_get_default (), "device-added",
G_CALLBACK (on_device_added), backend, 0);
META_BACKEND_CLASS (meta_backend_x11_parent_class)->post_init (backend);
}
static void
_set_cursor_location_internal(FcitxIMContext *fcitxcontext)
{
ClutterIMContext* context = CLUTTER_IM_CONTEXT(fcitxcontext);
ClutterActor *stage = clutter_actor_get_stage (context->actor);
Window current_window, root, parent, *childs;
unsigned int nchild;
XWindowAttributes winattr;
Display *xdpy;
float fx, fy;
gint x, y;
if (!stage)
return;
clutter_actor_get_transformed_position (context->actor, &fx, &fy);
x = fx;
y = fy;
xdpy = clutter_x11_get_default_display ();
current_window = clutter_x11_get_stage_window(CLUTTER_STAGE(stage));
if (!xdpy || !current_window)
return;
while(1) {
XGetWindowAttributes (xdpy, current_window, &winattr);
x += winattr.x;
y += winattr.y;
XQueryTree(xdpy, current_window, &root, &parent, &childs, &nchild);
current_window = parent;
if (root == parent)
break;
}
if (fcitxcontext->area.x != x || fcitxcontext->area.y != y) {
fcitxcontext->area.x = x;
fcitxcontext->area.y = y;
}
if (context->actor == NULL ||
!IsFcitxIMClientValid(fcitxcontext->client)) {
return;
}
ClutterIMRectangle area = fcitxcontext->area;
if (area.x == -1 && area.y == -1 && area.width == 0 && area.height == 0) {
area.y = 0;
area.x = 0;
}
FcitxIMClientSetCursorLocation(fcitxcontext->client, area.x, area.y + area.height);
return;
}
static void
mpl_panel_clutter_ensure_window (MplPanelClutter *panel)
{
MplPanelClutterPrivate *priv = panel->priv;
Window xwin = None;
Display *xdpy;
gint32 myint;
Atom atom1, atom2;
if (priv->xwindow)
return;
xdpy = clutter_x11_get_default_display ();
clutter_actor_realize (priv->stage);
priv->xwindow = xwin =
clutter_x11_get_stage_window (CLUTTER_STAGE (priv->stage));
g_object_set (panel, "xid", xwin, NULL);
if (priv->needs_gdk_pump)
mpl_panel_clutter_setup_events_with_gtk_for_xid (xwin);
if (!mpl_utils_panel_in_standalone_mode ())
{
MPL_X_ERROR_TRAP ();
/*
* Make dock, sticky and position at the correct place.
*/
atom1 = XInternAtom(xdpy, "_NET_WM_WINDOW_TYPE", False);
atom2 = XInternAtom(xdpy, "_NET_WM_WINDOW_TYPE_DOCK", False);
XChangeProperty (xdpy,
xwin,
atom1,
XA_ATOM, 32,
PropModeReplace, (unsigned char *) &atom2, 1);
atom1 = XInternAtom(xdpy, "_NET_WM_DESKTOP", False);
myint = -1;
XChangeProperty (xdpy,
xwin,
atom1,
XA_CARDINAL, 32,
PropModeReplace, (unsigned char *) &myint, 1);
XSync (xdpy, False);
MPL_X_ERROR_UNTRAP ();
}
}
static void
clutter_glx_texture_pixmap_dispose (GObject *object)
{
ClutterGLXTexturePixmapPrivate *priv;
priv = CLUTTER_GLX_TEXTURE_PIXMAP (object)->priv;
if (priv->glx_pixmap != None)
{
clutter_x11_trap_x_errors ();
glXDestroyGLXPixmap (clutter_x11_get_default_display(),
priv->glx_pixmap);
XSync (clutter_x11_get_default_display(), FALSE);
clutter_x11_untrap_x_errors ();
priv->glx_pixmap = None;
}
G_OBJECT_CLASS (clutter_glx_texture_pixmap_parent_class)->dispose (object);
}
Pixmap
create_pixmap (guint *width, guint *height, guint *depth)
{
Display *dpy = clutter_x11_get_default_display ();
cairo_surface_t *image;
Pixmap pixmap;
XVisualInfo xvisinfo;
XVisualInfo *xvisinfos;
int n;
cairo_surface_t *xlib_surface;
cairo_t *cr;
guint w, h;
image = cairo_image_surface_create_from_png (IMAGE);
if (cairo_surface_status (image) != CAIRO_STATUS_SUCCESS)
g_error ("Failed to load %s", IMAGE);
w = cairo_image_surface_get_width (image);
h = cairo_image_surface_get_height (image);
pixmap = XCreatePixmap (dpy,
DefaultRootWindow (dpy),
w, h,
32);
xvisinfo.depth = 32;
xvisinfos = XGetVisualInfo (dpy, VisualDepthMask, &xvisinfo, &n);
if (!xvisinfos)
g_error ("Failed to find a 32bit X Visual");
xlib_surface =
cairo_xlib_surface_create (dpy,
pixmap,
xvisinfos->visual,
w, h);
XFree (xvisinfos);
cr = cairo_create (xlib_surface);
cairo_set_source_surface (cr, image, 0, 0);
cairo_paint (cr);
cairo_surface_destroy (image);
if (width)
*width = w;
if (height)
*height = h;
if (depth)
*depth = 32;
return pixmap;
}
static void
xfixes_cursor_set_stage (ShellXFixesCursor *xfixes_cursor,
ClutterStage *stage)
{
if (xfixes_cursor->stage == stage)
return;
if (xfixes_cursor->stage)
{
g_signal_handlers_disconnect_by_func (xfixes_cursor->stage,
(void *)xfixes_cursor_on_stage_destroy,
xfixes_cursor);
clutter_x11_remove_filter (xfixes_cursor_event_filter, xfixes_cursor);
}
xfixes_cursor->stage = stage;
if (xfixes_cursor->stage)
{
int error_base;
xfixes_cursor->stage = stage;
g_signal_connect (xfixes_cursor->stage, "destroy",
G_CALLBACK (xfixes_cursor_on_stage_destroy), xfixes_cursor);
clutter_x11_add_filter (xfixes_cursor_event_filter, xfixes_cursor);
xfixes_cursor->have_xfixes = XFixesQueryExtension (clutter_x11_get_default_display (),
&xfixes_cursor->xfixes_event_base,
&error_base);
if (xfixes_cursor->have_xfixes)
XFixesSelectCursorInput (clutter_x11_get_default_display (),
clutter_x11_get_stage_window (stage),
XFixesDisplayCursorNotifyMask);
xfixes_cursor_reset_image (xfixes_cursor);
}
}
static void
clutter_glx_texture_pixmap_free_glx_pixmap (ClutterGLXTexturePixmap *texture)
{
ClutterGLXTexturePixmapPrivate *priv = texture->priv;
Display *dpy;
dpy = clutter_x11_get_default_display ();
if (priv->glx_pixmap &&
priv->bound)
{
texture_bind (texture);
clutter_x11_trap_x_errors ();
(_gl_release_tex_image) (dpy,
priv->glx_pixmap,
GLX_FRONT_LEFT_EXT);
XSync (clutter_x11_get_default_display(), FALSE);
if (clutter_x11_untrap_x_errors ())
CLUTTER_NOTE (TEXTURE, "Failed to release?");
CLUTTER_NOTE (TEXTURE, "Destroyed pxm: %li", priv->glx_pixmap);
priv->bound = FALSE;
}
clutter_x11_trap_x_errors ();
if (priv->glx_pixmap)
glXDestroyGLXPixmap (dpy, priv->glx_pixmap);
XSync (dpy, FALSE);
clutter_x11_untrap_x_errors ();
priv->glx_pixmap = None;
}
static void
free_shm_resources (ClutterX11TexturePixmap *texture)
{
ClutterX11TexturePixmapPrivate *priv;
priv = texture->priv;
if (priv->shminfo.shmid != -1)
{
XShmDetach(clutter_x11_get_default_display(),
&priv->shminfo);
shmdt(priv->shminfo.shmaddr);
shmctl(priv->shminfo.shmid, IPC_RMID, 0);
priv->shminfo.shmid = -1;
}
}
/**
* test_conform_simple_fixture_setup:
*
* Initialise stuff before each test is run
*/
void
test_conform_simple_fixture_setup (TestConformSimpleFixture *fixture,
gconstpointer data)
{
const TestConformSharedState *shared_state = data;
static int counter = 0;
if (counter != 0)
g_critical ("We don't support running more than one test at a time\n"
"in a single test run due to the state leakage that often\n"
"causes subsequent tests to fail.\n"
"\n"
"If you want to run all the tests you should run\n"
"$ make test-report");
counter++;
#ifdef HAVE_CLUTTER_GLX
{
/* on X11 we need a display connection to run the test suite */
const gchar *display = g_getenv ("DISPLAY");
if (!display || *display == '\0')
{
g_print ("No DISPLAY found. Unable to run the conformance "
"test suite without a display.\n");
exit (EXIT_SUCCESS);
}
}
#endif
g_assert (clutter_init (shared_state->argc_addr, shared_state->argv_addr)
== CLUTTER_INIT_SUCCESS);
#ifdef COGL_HAS_XLIB
/* A lot of the tests depend on a specific stage / framebuffer size
* when they read pixels back to verify the results of the test.
*
* Normally the asynchronous nature of X means that setting the
* clutter stage size may really happen an indefinite amount of time
* later but since the tests are so short lived and may only render
* a single frame this is not an acceptable semantic.
*/
XSynchronize (clutter_x11_get_default_display(), TRUE);
#endif
}
static void
set_above_and_fullscreen (void)
{
Display *dpy = clutter_x11_get_default_display ();
Window win = clutter_x11_get_stage_window (CLUTTER_STAGE (stage));
char *atom_names[2] = {
"_NET_WM_STATE_FULLSCREEN",
"_NET_WM_STATE_ABOVE",
};
Atom states[G_N_ELEMENTS (atom_names)];
XInternAtoms (dpy, atom_names, G_N_ELEMENTS (atom_names),
False, states);
XChangeProperty (dpy, win,
XInternAtom (dpy, "_NET_WM_STATE", False),
XA_ATOM, 32, PropModeReplace,
(unsigned char *) states, G_N_ELEMENTS (atom_names));
}
static void
mpl_panel_clutter_set_position (MplPanelClient *self, gint x, gint y)
{
MplPanelClutterPrivate *priv = MPL_PANEL_CLUTTER (self)->priv;
Display *xdpy = clutter_x11_get_default_display ();
MplPanelClientClass *p_class;
p_class = MPL_PANEL_CLIENT_CLASS (mpl_panel_clutter_parent_class);
mpl_panel_clutter_ensure_window ((MplPanelClutter*)self);
MPL_X_ERROR_TRAP ();
XMoveWindow (xdpy, priv->xwindow, x, y);
MPL_X_ERROR_UNTRAP ();
if (p_class->set_position)
p_class->set_position (self, x, y);
}
static void
free_damage_resources (ClutterX11TexturePixmap *texture)
{
ClutterX11TexturePixmapPrivate *priv;
Display *dpy;
priv = texture->priv;
dpy = clutter_x11_get_default_display();
if (priv->damage)
{
clutter_x11_trap_x_errors ();
XDamageDestroy (dpy, priv->damage);
XSync (dpy, FALSE);
clutter_x11_untrap_x_errors ();
priv->damage = None;
priv->damage_drawable = None;
}
clutter_x11_remove_filter (on_x_event_filter, (gpointer)texture);
}
void
clutter_x11_texture_pixmap_set_automatic (ClutterX11TexturePixmap *texture,
gboolean setting)
{
ClutterX11TexturePixmapPrivate *priv;
Display *dpy;
g_return_if_fail (CLUTTER_X11_IS_TEXTURE_PIXMAP (texture));
priv = texture->priv;
if (setting == priv->automatic_updates)
return;
dpy = clutter_x11_get_default_display();
if (setting == TRUE)
{
clutter_x11_add_filter (on_x_event_filter, (gpointer)texture);
clutter_x11_trap_x_errors ();
if (priv->window)
priv->damage_drawable = priv->window;
else
priv->damage_drawable = priv->pixmap;
priv->damage = XDamageCreate (dpy,
priv->damage_drawable,
XDamageReportNonEmpty);
XSync (dpy, FALSE);
clutter_x11_untrap_x_errors ();
}
else
free_damage_resources (texture);
priv->automatic_updates = setting;
}
static void
xfixes_cursor_hide (ShellXFixesCursor *xfixes_cursor)
{
int minor, major;
Display *xdisplay;
Window xwindow;
if (xfixes_cursor->is_showing == FALSE)
return;
if (!xfixes_cursor->have_xfixes || !xfixes_cursor->stage)
return;
xdisplay = clutter_x11_get_default_display ();
xwindow = clutter_x11_get_stage_window (xfixes_cursor->stage);
XFixesQueryVersion (xdisplay, &major, &minor);
if (major >= 4)
{
XFixesHideCursor (xdisplay, xwindow);
xfixes_cursor->is_showing = FALSE;
}
}
/**
* clutter_x11_has_composite_extension:
*
* Retrieves whether Clutter is running on an X11 server with the
* XComposite extension
*
* Return value: %TRUE if the XComposite extension is available
*/
gboolean
clutter_x11_has_composite_extension (void)
{
#if HAVE_XCOMPOSITE
static gboolean have_composite = FALSE, done_check = FALSE;
int error = 0, event = 0;
Display *dpy;
if (done_check)
return have_composite;
if (!_clutter_context_is_initialized ())
{
g_critical ("X11 backend has not been initialised");
return FALSE;
}
dpy = clutter_x11_get_default_display();
if (dpy == NULL)
return FALSE;
if (XCompositeQueryExtension (dpy, &event, &error))
{
int major = 0, minor = 0;
if (XCompositeQueryVersion (dpy, &major, &minor))
{
if (major >= 0 && minor >= 3)
have_composite = TRUE;
}
}
done_check = TRUE;
return have_composite;
#else
return FALSE;
#endif /* HAVE_XCOMPOSITE */
}
static gboolean
create_actor (GstGLClutterActor * actor)
{
static gint xpos = 0;
static gint ypos = 0;
Display *disp;
actor->texture = g_object_new (CLUTTER_GLX_TYPE_TEXTURE_PIXMAP,
"window", actor->win, "automatic-updates", TRUE, NULL);
clutter_container_add_actor (CLUTTER_CONTAINER (actor->stage),
actor->texture);
clutter_actor_set_position (actor->texture, xpos, ypos);
disp = clutter_x11_get_default_display ();
if (xpos > (COLS - 1) * W) {
xpos = 0;
ypos += H + 1;
} else
xpos += W + 1;
clutter_actor_show (actor->texture);
return FALSE;
}
