mutter/examples/cogl-x11-foreign.c
Robert Bragg cdbc1dc9b1 examples: Remove explicit framebuffer allocations
It used to be that cogl_framebuffer_allocate() had to be done explicitly
but we have since made Cogl lazily allocate framebuffers when they are
first used if they haven't already been explicitly allocated. Developers
only need to explicitly allocate framebuffers if they are planning to
gracefully handle any errors. In cases where the program will simply
abort due to an allocation error they can simply rely on implicit
allocation which will cause an abort on error.

This updates the examples to not explicitly allocate the framebuffers
since they all just abort on error anyway.

Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-09 13:09:15 +00:00

185 lines
5.1 KiB
C

#include <cogl/cogl.h>
#include <cogl/cogl-xlib.h>
#include <glib.h>
#include <stdio.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#define X11_FOREIGN_EVENT_MASK \
(KeyPressMask | \
KeyReleaseMask | \
ButtonPressMask | \
ButtonReleaseMask | \
PointerMotionMask)
CoglColor black;
static void
update_cogl_x11_event_mask (CoglOnscreen *onscreen,
guint32 event_mask,
void *user_data)
{
Display *xdpy = user_data;
XSetWindowAttributes attrs;
guint32 xwin;
attrs.event_mask = event_mask | X11_FOREIGN_EVENT_MASK;
xwin = cogl_x11_onscreen_get_window_xid (onscreen);
XChangeWindowAttributes (xdpy,
(Window)xwin,
CWEventMask,
&attrs);
}
int
main (int argc, char **argv)
{
Display *xdpy;
CoglRenderer *renderer;
CoglSwapChain *chain;
CoglOnscreenTemplate *onscreen_template;
CoglDisplay *display;
CoglContext *ctx;
CoglOnscreen *onscreen;
CoglFramebuffer *fb;
GError *error = NULL;
guint32 visual;
XVisualInfo template, *xvisinfo;
int visinfos_count;
XSetWindowAttributes xattr;
unsigned long mask;
Window xwin;
CoglVertexP2C4 triangle_vertices[] = {
{0, 0.7, 0xff, 0x00, 0x00, 0x80},
{-0.7, -0.7, 0x00, 0xff, 0x00, 0xff},
{0.7, -0.7, 0x00, 0x00, 0xff, 0xff}
};
CoglPrimitive *triangle;
/* Since we want to test external ownership of the X display,
* connect to X manually... */
xdpy = XOpenDisplay (NULL);
if (!xdpy)
{
fprintf (stderr, "Failed to open X Display\n");
return 1;
}
/* Conceptually choose a GPU... */
renderer = cogl_renderer_new ();
/* FIXME: This should conceptually be part of the configuration of
* a renderer. */
cogl_xlib_renderer_set_foreign_display (renderer, xdpy);
if (!cogl_renderer_connect (renderer, &error))
{
fprintf (stderr, "Failed to connect to a renderer: %s\n",
error->message);
}
chain = cogl_swap_chain_new ();
cogl_swap_chain_set_has_alpha (chain, TRUE);
/* Conceptually declare upfront the kinds of windows we anticipate
* creating so that when we configure the display pipeline we can avoid
* having an impedance miss-match between the format of windows and the
* format the display pipeline expects. */
onscreen_template = cogl_onscreen_template_new (chain);
cogl_object_unref (chain);
/* Conceptually setup a display pipeline */
display = cogl_display_new (renderer, onscreen_template);
cogl_object_unref (renderer);
if (!cogl_display_setup (display, &error))
{
fprintf (stderr, "Failed to setup a display pipeline: %s\n",
error->message);
return 1;
}
ctx = cogl_context_new (display, &error);
if (!ctx)
{
fprintf (stderr, "Failed to create context: %s\n", error->message);
return 1;
}
onscreen = cogl_onscreen_new (ctx, 640, 480);
/* We want to test that Cogl can handle foreign X windows... */
visual = cogl_x11_onscreen_get_visual_xid (onscreen);
if (!visual)
{
fprintf (stderr, "Failed to query an X visual suitable for the "
"configured CoglOnscreen framebuffer\n");
return 1;
}
template.visualid = visual;
xvisinfo = XGetVisualInfo (xdpy, VisualIDMask, &template, &visinfos_count);
/* window attributes */
xattr.background_pixel = WhitePixel (xdpy, DefaultScreen (xdpy));
xattr.border_pixel = 0;
xattr.colormap = XCreateColormap (xdpy,
DefaultRootWindow (xdpy),
xvisinfo->visual,
AllocNone);
mask = CWBorderPixel | CWColormap;
xwin = XCreateWindow (xdpy,
DefaultRootWindow (xdpy),
0, 0,
800, 600,
0,
xvisinfo->depth,
InputOutput,
xvisinfo->visual,
mask, &xattr);
XFree (xvisinfo);
cogl_x11_onscreen_set_foreign_window_xid (onscreen, xwin,
update_cogl_x11_event_mask,
xdpy);
XMapWindow (xdpy, xwin);
fb = COGL_FRAMEBUFFER (onscreen);
cogl_push_framebuffer (fb);
triangle = cogl_primitive_new_p2c4 (COGL_VERTICES_MODE_TRIANGLES,
3, triangle_vertices);
for (;;)
{
CoglPollFD *poll_fds;
int n_poll_fds;
gint64 timeout;
while (XPending (xdpy))
{
XEvent event;
XNextEvent (xdpy, &event);
switch (event.type)
{
case KeyRelease:
case ButtonRelease:
return 0;
}
cogl_xlib_renderer_handle_event (renderer, &event);
}
cogl_clear (&black, COGL_BUFFER_BIT_COLOR);
cogl_primitive_draw (triangle);
cogl_framebuffer_swap_buffers (fb);
cogl_poll_get_info (ctx, &poll_fds, &n_poll_fds, &timeout);
g_poll ((GPollFD *) poll_fds, n_poll_fds, 0);
cogl_poll_dispatch (ctx, poll_fds, n_poll_fds);
}
return 0;
}