Xorg. Обработка сообщений. SIGSEGV

/* Simple XCB application drawing a box in a window */
 
#include <xcb/xcb.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
 
int
main (int argc, char **argv)
{
  xcb_connection_t *c;
  xcb_screen_t *s;
  xcb_window_t w;
  xcb_gcontext_t g;
  xcb_generic_event_t *e;
  uint32_t mask;
  uint32_t values[2];
  int done;
  xcb_rectangle_t r = { 20, 20, 60, 60 };
 
  /* open connection with the server */
 
  c = xcb_connect (NULL, NULL);
 
  if (!c)
    {
      printf ("Cannot open display\n");
      exit (1);
    }
 
  s = xcb_setup_roots_iterator (xcb_get_setup (c)).data;
 
  /* create window */
 
  mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;
  values[0] = s->white_pixel;
  values[1] = XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_KEY_PRESS;
 
  w = xcb_generate_id (c);
  xcb_create_window (c, XCB_COPY_FROM_PARENT, w, s->root,
                     10, 10, 100, 100, 1,
                     XCB_WINDOW_CLASS_INPUT_OUTPUT,
                     s->root_visual,
                     mask, values);
 
  /* create black graphics context */
 
  mask = XCB_GC_FOREGROUND | XCB_GC_GRAPHICS_EXPOSURES;
  values[0] = s->black_pixel;
  values[1] = 0;
 
  g = xcb_generate_id (c);
  xcb_create_gc (c, g, w, mask, values);
 
  /* map (show) the window */
 
  xcb_map_window (c, w);
 
  xcb_flush (c);
 
  /* event loop */
 
  while (!done && (e = xcb_wait_for_event (c)))
    {
      switch (e->response_type)
        {
        /* (re)draw the window */
        case XCB_EXPOSE:
          printf ("EXPOSE\n");
          xcb_poly_fill_rectangle (c, w, g, 1, &r);
          xcb_flush (c);
          break;
 
        /* exit on keypress */
        case XCB_KEY_PRESS:
          done = 1;
          break;
        }
      free (e);
    }
 
    /* close connection to server */
 
    xcb_disconnect (c);
 
    return 0;
}

GLXContext mGlCtx;
Display* mDisplay;
xcb_connection_t* mXcbConnection;

void foo(void)
{
	//open display
	mDisplay = XOpenDisplay( NULL );
	if(mDisplay == NULL)
	{
		LogError("Could not open display");
		exit(1);
	}
	//get screen
	int LocalDefaultScreen = DefaultScreen(mDisplay);
	//get the XCB connection from the display
	mXcbConnection = XGetXCBConnection(mDisplay);
        if(mXcbConnection == NULL)
        {
            XCloseDisplay(mDisplay);
            LogError( "Can't get xcb connection from display");
            exit(1);
        }
	//Acquire event queue ownership
        XSetEventQueueOwner(mDisplay, XCBOwnsEventQueue);
        //Find XCB screen
        xcb_screen_t* Screen = 0;
        xcb_screen_iterator_t ScreenIterator = xcb_setup_roots_iterator(xcb_get_setup(mXcbConnection));
        int ScreenNum;
        for (ScreenNum = LocalDefaultScreen; ScreenIterator.rem && ScreenNum > 0; --ScreenNum, xcb_screen_next(&ScreenIterator));
        Screen = ScreenIterator.data;

        //Initialize window and OpenGL context, run main loop and deinitialize
        int VisualID = 0;

        //Query framebuffer configurations
        GLXFBConfig *fb_configs = 0;
        int num_fb_configs = 0;
        fb_configs = glXGetFBConfigs(mDisplay, LocalDefaultScreen, &num_fb_configs);
        if(!fb_configs || num_fb_configs == 0)
        {
            LogError("glXGetFBConfigs failed");
            exit(1);
        }
        //Select first framebuffer config and query visualID
        GLXFBConfig fb_config = fb_configs[0];
        glXGetFBConfigAttrib(mDisplay, fb_config, GLX_VISUAL_ID , &VisualID);

        //Create OpenGL context
        mGlCtx = glXCreateNewContext(mDisplay, fb_config, GLX_RGBA_TYPE, 0, True);
        if(!mGlCtx)
        {
            LogError("glXCreateNewContext failed");
            exit(1);
        }
        //Create XID's for colormap and window
        xcb_colormap_t colormap = xcb_generate_id(mXcbConnection);
        xcb_window_t window = xcb_generate_id(mXcbConnection);
        //Create colormap
        xcb_create_colormap(mXcbConnection, XCB_COLORMAP_ALLOC_NONE, colormap, Screen->root, VisualID);
        //Create window
        uint32_t eventmask = XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_KEY_PRESS;
        uint32_t valuelist[] = { eventmask, colormap, 0 };
        uint32_t valuemask = XCB_CW_EVENT_MASK | XCB_CW_COLORMAP;

        xcb_create_window(
            mXcbConnection,
            XCB_COPY_FROM_PARENT,
            window,
            Screen->root,
            0, 0,
            640, 480,
            0,
            XCB_WINDOW_CLASS_INPUT_OUTPUT,
            VisualID,
            valuemask,
            valuelist
            );
        // NOTE: window must be mapped before glXMakeContextCurrent
        xcb_map_window(mXcbConnection, window);
        //Create GLX Window
        GLXDrawable drawable = 0;

        GLXWindow glxwindow = glXCreateWindow(mDisplay, fb_config, window, 0 );

        if(!window)
        {
            xcb_destroy_window(mXcbConnection, window);
            glXDestroyContext(mDisplay, mGlCtx);

            LogError("glXDestroyContext failed");
            exit(1);
        }

        drawable = glxwindow;
        //make OpenGL context current
        if(!glXMakeContextCurrent(mDisplay, drawable, drawable, mGlCtx))
        {
            xcb_destroy_window(mXcbConnection, window);
            glXDestroyContext(mDisplay, mGlCtx);

            LogError("glXMakeContextCurrent failed");
            exit(1);
        }
}

void bar(void)
{
	while(true)
	{
		//Wait for event
		xcb_generic_event_t *event = xcb_wait_for_event(mXcbConnection);
		if(!event)
		{
			LogError("I/O error in xcb_wait_for_event. mXcbConnection = %016llX", mXcbConnection);
			exit(1);
		}

		switch(event->response_type & ~0x80)
		{
			//case XCB_KEY_PRESS:
			//Quit on key press
				//break;
			case XCB_EXPOSE:
				//Handle expose event, draw and swap buffers
				SwapBuffers();
				break;
			default:
				break;
		}

		free(event);
	}
}