static bool init_touch_input(void)
{
unsigned i;
ALLEGRO_SYSTEM* system;
if (installed)
return false;
if (!_al_win_init_touch_input_api())
return false;
memset(&touch_input_state, 0, sizeof(touch_input_state));
_al_event_source_init(&touch_input.es);
_al_event_source_init(&touch_input.mouse_emulation_es);
touch_input.mouse_emulation_mode = ALLEGRO_MOUSE_EMULATION_TRANSPARENT;
installed = true;
system = al_get_system_driver();
for (i = 0; i < _al_vector_size(&system->displays); ++i) {
bool r;
ALLEGRO_DISPLAY_WIN *win_display = *((ALLEGRO_DISPLAY_WIN**)_al_vector_ref(&system->displays, i));
r = _al_win_register_touch_window(win_display->window, 0);
ALLEGRO_INFO("registering touch window %p: %d\n", win_display, r);
if (!r) {
ALLEGRO_ERROR("RegisterTouchWindow failed: %s\n", get_error_desc(GetLastError()));
return false;
}
}
return true;
}
/* xmouse_init:
* Initialise the driver.
*/
static bool xmouse_init(void)
{
ALLEGRO_SYSTEM_XGLX *system = (void *)al_get_system_driver();
ALLEGRO_DISPLAY *display;
int x, y;
if (system->x11display == NULL)
return false;
if (xmouse_installed)
return false;
/* Don't clobber mouse position in case the display was created before
* the mouse is installed.
*/
display = the_mouse.state.display;
x = the_mouse.state.x;
y = the_mouse.state.y;
memset(&the_mouse, 0, sizeof the_mouse);
the_mouse.state.display = display;
the_mouse.state.x = x;
the_mouse.state.y = y;
_al_event_source_init(&the_mouse.parent.es);
xmouse_installed = true;
return true;
}
/* init_keyboard:
* Initialise the keyboard driver.
*/
static bool init_keyboard(void)
{
memset(&the_keyboard, 0, sizeof the_keyboard);
memset(&the_state, 0, sizeof the_state);
modifiers = 0;
/* Initialise the keyboard object for use as an event source. */
_al_event_source_init(&the_keyboard.es);
installed = true;
return true;
}
/* xkeybd_init_keyboard:
* Initialise the driver.
*/
static bool xkeybd_init_keyboard(void)
{
if (x_keyboard_init() != 0)
return false;
memset(&the_keyboard, 0, sizeof the_keyboard);
_al_event_source_init(&the_keyboard.parent.es);
//_xwin_keydrv_set_leds(_key_shifts);
/* Get the pid, which we use for the three finger salute */
main_pid = getpid();
return true;
}
static ALLEGRO_DISPLAY *iphone_create_display(int w, int h)
{
ALLEGRO_DISPLAY_IPHONE *d = al_calloc(1, sizeof *d);
ALLEGRO_DISPLAY *display = (void*)d;
ALLEGRO_OGL_EXTRAS *ogl = al_calloc(1, sizeof *ogl);
display->ogl_extras = ogl;
display->vt = _al_get_iphone_display_interface();
display->flags = al_get_new_display_flags();
if (display->flags & ALLEGRO_FULLSCREEN_WINDOW) {
_al_iphone_get_screen_size(&w, &h);
}
display->w = w;
display->h = h;
ALLEGRO_SYSTEM_IPHONE *system = (void *)al_get_system_driver();
/* Add ourself to the list of displays. */
ALLEGRO_DISPLAY_IPHONE **add;
add = _al_vector_alloc_back(&system->system.displays);
*add = d;
/* Each display is an event source. */
_al_event_source_init(&display->es);
_al_iphone_update_visuals();
ALLEGRO_EXTRA_DISPLAY_SETTINGS *eds[system->visuals_count];
memcpy(eds, system->visuals, sizeof(*eds) * system->visuals_count);
qsort(eds, system->visuals_count, sizeof(*eds), _al_display_settings_sorter);
ALLEGRO_INFO("Chose visual no. %i\n", eds[0]->index);
memcpy(&display->extra_settings, eds[0], sizeof(ALLEGRO_EXTRA_DISPLAY_SETTINGS));
/* This will add an OpenGL view with an OpenGL context, then return. */
_al_iphone_add_view(display);
_al_iphone_make_view_current();
_al_ogl_manage_extensions(display);
_al_ogl_set_extensions(ogl->extension_api);
setup_gl(display);
display->flags |= ALLEGRO_OPENGL;
return display;
}
/* Create a new X11 display, which maps directly to a GLX window. */
static ALLEGRO_DISPLAY *gp2xwiz_create_display_fb(int w, int h)
{
(void)w;
(void)h;
/* Only one display allowed at a time */
if (set_gfx_mode)
return NULL;
lc_init_rest();
ALLEGRO_DISPLAY_GP2XWIZ_FB *d = _AL_MALLOC(sizeof *d);
ALLEGRO_DISPLAY *display = (void *)d;
memset(d, 0, sizeof *d);
ALLEGRO_SYSTEM_GP2XWIZ *system = (void *)al_get_system_driver();
display->w = 320;
display->h = 240;
display->vt = _al_display_gp2xwiz_framebuffer_driver();
display->refresh_rate = 60;
display->flags = al_get_new_display_flags();
display->flags |= ALLEGRO_FULLSCREEN;
/* Add ourself to the list of displays. */
ALLEGRO_DISPLAY_GP2XWIZ_FB **add;
add = _al_vector_alloc_back(&system->system.displays);
*add = d;
/* Each display is an event source. */
_al_event_source_init(&display->es);
/* Create a backbuffer and point it to the framebuffer */
al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP);
d->backbuffer = al_create_bitmap(320, 240);
d->screen_mem = d->backbuffer->memory;
d->backbuffer->memory = (unsigned char *)lc_fb1;
set_gfx_mode = true;
ALLEGRO_DEBUG("Display created successfully\n");
return display;
}
static ALLEGRO_DISPLAY* wgl_create_display(int w, int h)
{
ALLEGRO_SYSTEM_WIN *system = (ALLEGRO_SYSTEM_WIN *)al_get_system_driver();
ALLEGRO_DISPLAY_WGL **add;
ALLEGRO_DISPLAY_WGL *wgl_display = al_calloc(1, sizeof *wgl_display);
ALLEGRO_DISPLAY *ogl_display = (void*)wgl_display;
ALLEGRO_DISPLAY *display = (void*)ogl_display;
ALLEGRO_DISPLAY_WIN *win_disp = (ALLEGRO_DISPLAY_WIN *)display;
win_disp->adapter = _al_win_determine_adapter();
display->w = w;
display->h = h;
display->refresh_rate = al_get_new_display_refresh_rate();
display->flags = al_get_new_display_flags();
display->vt = &vt;
display->ogl_extras = al_calloc(1, sizeof(ALLEGRO_OGL_EXTRAS));
if (!create_display_internals(wgl_display)) {
al_free(display->ogl_extras);
al_free(display);
return NULL;
}
/* Print out OpenGL version info */
ALLEGRO_INFO("OpenGL Version: %s\n", (const char*)glGetString(GL_VERSION));
ALLEGRO_INFO("Vendor: %s\n", (const char*)glGetString(GL_VENDOR));
ALLEGRO_INFO("Renderer: %s\n\n", (const char*)glGetString(GL_RENDERER));
/* Add ourself to the list of displays. */
add = _al_vector_alloc_back(&system->system.displays);
*add = wgl_display;
/* Each display is an event source. */
_al_event_source_init(&display->es);
_al_win_set_system_mouse_cursor(display, ALLEGRO_SYSTEM_MOUSE_CURSOR_ARROW);
_al_win_show_mouse_cursor(display);
return display;
}
/* Function: al_init_user_event_source
*/
void al_init_user_event_source(ALLEGRO_EVENT_SOURCE *src)
{
ASSERT(src);
_al_event_source_init(src);
}
static bool android_init_keyboard(void)
{
memset(&the_keyboard, 0, sizeof the_keyboard);
_al_event_source_init(&the_keyboard.es);
return true;
}
/* lkeybd_init_keyboard: [primary thread]
* Initialise the keyboard driver.
*/
static bool lkeybd_init_keyboard(void)
{
bool can_restore_termio_and_kbmode = false;
memset(&the_keyboard, 0, sizeof the_keyboard);
/*
if (__al_linux_use_console())
return false;
*/
the_keyboard.fd = open("/dev/tty", O_RDWR);
/* Save the current terminal attributes, which we will restore when
* we close up shop.
*/
if (tcgetattr(the_keyboard.fd, &the_keyboard.startup_termio) != 0) {
goto Error;
}
/* Save previous keyboard mode (probably XLATE). */
if (ioctl(the_keyboard.fd, KDGKBMODE, &the_keyboard.startup_kbmode) != 0) {
//goto Error;
}
can_restore_termio_and_kbmode = false;
/* Set terminal attributes we need.
*
* Input modes (c_iflag): We want to disable:
* - stripping bytes to 7 bits
* - ignoring of carriage returns
* - translating of carriage returns to newlines, and vice versa
* - start/stop control on input and output
*
* Control modes (c_cflag): We want 8 bits per byte.
*
* Local modes (c_lflag: We want to disable:
* - canonical (line by line) input
* - echoing input back to the display
* - interpretation of signal characters
*
* The c_iflag, c_lflag settings come from svgalib. Allegro 4
* simply set them to 0, which is a bit crude.
*/
the_keyboard.work_termio = the_keyboard.startup_termio;
the_keyboard.work_termio.c_iflag &= ~(ISTRIP | IGNCR | ICRNL | INLCR | IXOFF | IXON);
the_keyboard.work_termio.c_cflag &= ~CSIZE;
the_keyboard.work_termio.c_cflag |= CS8;
the_keyboard.work_termio.c_lflag &= ~(ICANON | ECHO | ISIG);
if (tcsetattr(the_keyboard.fd, TCSANOW, &the_keyboard.work_termio) != 0) {
goto Error;
}
/* Set the keyboard mode to mediumraw. */
if (ioctl(the_keyboard.fd, KDSKBMODE, K_MEDIUMRAW) != 0) {
//goto Error;
}
the_keyboard.three_finger_flag = true;
the_keyboard.key_led_flag = true;
const char *value = al_get_config_value(al_get_system_config(),
"keyboard", "enable_three_finger_exit");
if (value) {
the_keyboard.three_finger_flag = !strncmp(value, "true", 4);
}
value = al_get_config_value(al_get_system_config(),
"keyboard", "enable_key_led_toggle");
if (value) {
the_keyboard.key_led_flag = !strncmp(value, "true", 4);
}
ALLEGRO_DEBUG("Three finger flag enabled: %s\n",
the_keyboard.three_finger_flag ? "true" : "false");
ALLEGRO_DEBUG("Key LED toggle enabled: %s\n",
the_keyboard.key_led_flag ? "true" : "false");
/* Initialise the keyboard object for use as an event source. */
_al_event_source_init(&the_keyboard.parent.es);
/* Start watching for data on the fd. */
_al_unix_start_watching_fd(the_keyboard.fd, process_new_data, NULL);
/* Get the pid, which we use for the three finger salute */
main_pid = getpid();
return true;
Error:
if (can_restore_termio_and_kbmode) {
tcsetattr(the_keyboard.fd, TCSANOW, &the_keyboard.startup_termio);
ioctl(the_keyboard.fd, KDSKBMODE, the_keyboard.startup_kbmode);
}
close(the_keyboard.fd);
/*
__al_linux_leave_console();
*/
return false;
}
static ALLEGRO_DISPLAY *raspberrypi_create_display(int w, int h)
{
ALLEGRO_DISPLAY_RASPBERRYPI *d = al_calloc(1, sizeof *d);
ALLEGRO_DISPLAY *display = (void*)d;
ALLEGRO_OGL_EXTRAS *ogl = al_calloc(1, sizeof *ogl);
display->ogl_extras = ogl;
display->vt = _al_get_raspberrypi_display_interface();
display->flags = al_get_new_display_flags();
ALLEGRO_SYSTEM_RASPBERRYPI *system = (void *)al_get_system_driver();
/* Add ourself to the list of displays. */
ALLEGRO_DISPLAY_RASPBERRYPI **add;
add = _al_vector_alloc_back(&system->system.displays);
*add = d;
/* Each display is an event source. */
_al_event_source_init(&display->es);
display->extra_settings.settings[ALLEGRO_COMPATIBLE_DISPLAY] = 1;
display->w = w;
display->h = h;
if (!pi_create_display(display)) {
// FIXME: cleanup
return NULL;
}
if (getenv("DISPLAY")) {
_al_mutex_lock(&system->lock);
Window root = RootWindow(
system->x11display, DefaultScreen(system->x11display));
XWindowAttributes attr;
XGetWindowAttributes(system->x11display, root, &attr);
d->window = XCreateWindow(
system->x11display,
root,
0,
0,
attr.width,
attr.height,
0, 0,
InputOnly,
DefaultVisual(system->x11display, 0),
0,
NULL
);
XGetWindowAttributes(system->x11display, d->window, &attr);
XSelectInput(
system->x11display,
d->window,
PointerMotionMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask
);
XMapWindow(system->x11display, d->window);
_al_xwin_reset_size_hints(display);
_al_xwin_set_fullscreen_window(display, 2);
_al_xwin_set_size_hints(display, INT_MAX, INT_MAX);
d->wm_delete_window_atom = XInternAtom(system->x11display,
"WM_DELETE_WINDOW", False);
XSetWMProtocols(system->x11display, d->window, &d->wm_delete_window_atom, 1);
_al_mutex_unlock(&system->lock);
}
al_grab_mouse(display);
_al_ogl_manage_extensions(display);
_al_ogl_set_extensions(ogl->extension_api);
setup_gl(display);
al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_INVERSE_ALPHA);
display->flags |= ALLEGRO_OPENGL;
if (al_is_mouse_installed() && !getenv("DISPLAY")) {
_al_evdev_set_mouse_range(0, 0, display->w-1, display->h-1);
}
set_cursor_data(d, default_cursor, DEFAULT_CURSOR_WIDTH, DEFAULT_CURSOR_HEIGHT);
return display;
}
static ALLEGRO_DISPLAY *sdl_create_display_locked(int w, int h)
{
ALLEGRO_DISPLAY_SDL *sdl = al_calloc(1, sizeof *sdl);
ALLEGRO_DISPLAY *d = (void *)sdl;
d->w = w;
d->h = h;
d->flags = al_get_new_display_flags();
d->flags |= ALLEGRO_OPENGL;
int flags = SDL_WINDOW_OPENGL;
if (d->flags & ALLEGRO_FULLSCREEN)
flags |= SDL_WINDOW_FULLSCREEN;
if (d->flags & ALLEGRO_FULLSCREEN_WINDOW)
flags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
if (d->flags & ALLEGRO_FRAMELESS)
flags |= SDL_WINDOW_BORDERLESS;
if (d->flags & ALLEGRO_RESIZABLE)
flags |= SDL_WINDOW_RESIZABLE;
GLoption(ALLEGRO_COLOR_SIZE, SDL_GL_BUFFER_SIZE);
GLoption(ALLEGRO_RED_SIZE, SDL_GL_RED_SIZE);
GLoption(ALLEGRO_GREEN_SIZE, SDL_GL_GREEN_SIZE);
GLoption(ALLEGRO_BLUE_SIZE, SDL_GL_BLUE_SIZE);
GLoption(ALLEGRO_ALPHA_SIZE, SDL_GL_ALPHA_SIZE);
GLoption(ALLEGRO_ACC_RED_SIZE, SDL_GL_ACCUM_RED_SIZE);
GLoption(ALLEGRO_ACC_GREEN_SIZE, SDL_GL_ACCUM_GREEN_SIZE);
GLoption(ALLEGRO_ACC_BLUE_SIZE, SDL_GL_ACCUM_BLUE_SIZE);
GLoption(ALLEGRO_ACC_ALPHA_SIZE, SDL_GL_ACCUM_ALPHA_SIZE);
GLoption(ALLEGRO_STEREO, SDL_GL_STEREO);
GLoption(ALLEGRO_DEPTH_SIZE, SDL_GL_DEPTH_SIZE);
GLoption(ALLEGRO_STENCIL_SIZE, SDL_GL_STENCIL_SIZE);
GLoption(ALLEGRO_SAMPLE_BUFFERS, SDL_GL_MULTISAMPLEBUFFERS);
GLoption(ALLEGRO_SAMPLES, SDL_GL_MULTISAMPLESAMPLES);
sdl->window = SDL_CreateWindow(sdl->title, sdl->x, sdl->y,
d->w, d->h, flags);
if (!sdl->window) {
ALLEGRO_ERROR("SDL_CreateWindow failed: %s", SDL_GetError());
return NULL;
}
flags =
SDL_RENDERER_ACCELERATED |
SDL_RENDERER_PRESENTVSYNC |
SDL_RENDERER_TARGETTEXTURE;
sdl->renderer = SDL_CreateRenderer(sdl->window, -1, flags);
sdl->context = SDL_GL_CreateContext(sdl->window);
ALLEGRO_DISPLAY **add;
ALLEGRO_SYSTEM *system = al_get_system_driver();
add = _al_vector_alloc_back(&system->displays);
*add = d;
_al_event_source_init(&d->es);
d->vt = vt;
d->extra_settings.settings[ALLEGRO_COMPATIBLE_DISPLAY] = true;
d->ogl_extras = al_calloc(1, sizeof *d->ogl_extras);
_al_ogl_manage_extensions(d);
_al_ogl_set_extensions(d->ogl_extras->extension_api);
_al_ogl_setup_gl(d);
return d;
}
/* ljoy_get_joystick: [primary thread]
*
* Returns the address of a ALLEGRO_JOYSTICK structure for the device
* number NUM. The top-level joystick functions will not call this
* function if joystick number NUM was already gotten. If the
* device cannot be opened, NULL is returned.
*/
static ALLEGRO_JOYSTICK *ljoy_get_joystick(int num)
{
ALLEGRO_JOYSTICK_LINUX *joy;
int fd;
/* Try to open the device. */
fd = try_open_joy_device(num);
if (fd == -1)
return NULL;
/* Allocate a structure for the joystick. */
joy = _AL_MALLOC(sizeof *joy);
if (!joy) {
close(fd);
return NULL;
}
memset(joy, 0, sizeof *joy);
/* Initialise the event source part of it. */
_al_event_source_init(&joy->parent.es);
/* Fill in the joystick information fields. */
{
/* char tmp[128], tmp1[128], tmp2[128]; */
char num_axes;
char num_buttons;
int throttle;
int s, a, b;
ioctl(fd, JSIOCGAXES, &num_axes);
ioctl(fd, JSIOCGBUTTONS, &num_buttons);
if (num_axes > TOTAL_JOYSTICK_AXES)
num_axes = TOTAL_JOYSTICK_AXES;
if (num_buttons > _AL_MAX_JOYSTICK_BUTTONS)
num_buttons = _AL_MAX_JOYSTICK_BUTTONS;
/* XXX use configuration system when we get one */
throttle = -1;
#if 0
/* User is allowed to override our simple assumption of which
* axis number (kernel) the throttle is located at. */
snprintf(tmp, sizeof(tmp), "throttle_axis_%d", num);
throttle = get_config_int("joystick", tmp, -1);
if (throttle == -1) {
throttle = get_config_int("joystick",
"throttle_axis", -1);
}
#endif
/* Each pair of axes is assumed to make up a stick unless it
* is the sole remaining axis, or has been user specified, in
* which case it is a throttle. */
for (s = 0, a = 0;
s < _AL_MAX_JOYSTICK_STICKS && a < num_axes;
s++)
{
if ((a == throttle) || (a == num_axes-1)) {
/* One axis throttle. */
joy->parent.info.stick[s].flags = ALLEGRO_JOYFLAG_ANALOGUE;
joy->parent.info.stick[s].num_axes = 1;
joy->parent.info.stick[s].axis[0].name = "Throttle";
char *name = joy->parent.info.stick[s].axis[0].name;
joy->parent.info.stick[s].name = _AL_MALLOC_ATOMIC(strlen(name) + 1);
strcpy(joy->parent.info.stick[s].name, name);
joy->axis_mapping[a].stick = s;
joy->axis_mapping[a].axis = 0;
a++;
}
else {
/* Two axis stick. */
joy->parent.info.stick[s].flags = ALLEGRO_JOYFLAG_ANALOGUE;
joy->parent.info.stick[s].num_axes = 2;
joy->parent.info.stick[s].axis[0].name = "X";
joy->parent.info.stick[s].axis[1].name = "Y";
joy->parent.info.stick[s].name = _AL_MALLOC_ATOMIC (32);
snprintf((char *)joy->parent.info.stick[s].name, 32, "Stick %d", s+1);
joy->axis_mapping[a].stick = s;
joy->axis_mapping[a].axis = 0;
a++;
joy->axis_mapping[a].stick = s;
joy->axis_mapping[a].axis = 1;
a++;
}
}
joy->parent.info.num_sticks = s;
/* Do the buttons. */
for (b = 0; b < num_buttons; b++) {
joy->parent.info.button[b].name = _AL_MALLOC_ATOMIC (32);
snprintf((char *)joy->parent.info.button[b].name, 32, "B%d", b+1);
}
joy->parent.info.num_buttons = num_buttons;
}
joy->parent.num = num;
joy->fd = fd;
/* Register the joystick with the fdwatch subsystem. */
_al_unix_start_watching_fd(joy->fd, ljoy_process_new_data, joy);
return (ALLEGRO_JOYSTICK *) joy;
}
/* Create a new X11 display, which maps directly to a GLX window. */
static ALLEGRO_DISPLAY *xdpy_create_display(int w, int h)
{
ALLEGRO_SYSTEM_XGLX *system = (void *)al_get_system_driver();
int adapter = al_get_new_display_adapter();
if (system->x11display == NULL) {
ALLEGRO_WARN("Not connected to X server.\n");
return NULL;
}
if (w <= 0 || h <= 0) {
ALLEGRO_ERROR("Invalid window size %dx%d\n", w, h);
return NULL;
}
_al_mutex_lock(&system->lock);
ALLEGRO_DISPLAY_XGLX *d = al_calloc(1, sizeof *d);
ALLEGRO_DISPLAY *display = (void*)d;
ALLEGRO_OGL_EXTRAS *ogl = al_calloc(1, sizeof *ogl);
display->ogl_extras = ogl;
int major, minor;
glXQueryVersion(system->x11display, &major, &minor);
d->glx_version = major * 100 + minor * 10;
ALLEGRO_INFO("GLX %.1f.\n", d->glx_version / 100.f);
display->w = w;
display->h = h;
display->vt = _al_display_xglx_driver();
display->refresh_rate = al_get_new_display_refresh_rate();
display->flags = al_get_new_display_flags();
// FIXME: default? Is this the right place to set this?
display->flags |= ALLEGRO_OPENGL;
// store our initial virtual adapter, used by fullscreen and positioning code
d->adapter = adapter;
ALLEGRO_DEBUG("selected adapter %i\n", adapter);
if (d->adapter < 0) {
d->adapter = _al_xglx_get_default_adapter(system);
}
_al_xglx_use_adapter(system, d->adapter);
/* if we're in multi-head X mode, bail if we try to use more than one display
* as there are bugs in X/glX that cause us to hang in X if we try to use more than one. */
/* if we're in real xinerama mode, also bail, x makes mouse use evil */
bool true_xinerama_active = false;
#ifdef ALLEGRO_XWINDOWS_WITH_XINERAMA
bool xrandr_active = false;
#ifdef ALLEGRO_XWINDOWS_WITH_XRANDR
xrandr_active = system->xrandr_available;
#endif
true_xinerama_active = !xrandr_active && system->xinerama_available;
#endif
if ((true_xinerama_active || ScreenCount(system->x11display) > 1) && system->adapter_use_count) {
uint32_t i, adapter_use_count = 0;
for (i = 0; i < 32; i++) {
if (system->adapter_map[i])
adapter_use_count++;
}
if (adapter_use_count > 1) {
ALLEGRO_ERROR("Use of more than one adapter at once in multi-head X or X with true Xinerama active is not possible.\n");
al_free(d);
al_free(ogl);
_al_mutex_unlock(&system->lock);
return NULL;
}
}
ALLEGRO_DEBUG("xdpy: selected adapter %i\n", d->adapter);
// store or initial X Screen, used by window creation, fullscreen, and glx visual code
d->xscreen = _al_xglx_get_xscreen(system, d->adapter);
ALLEGRO_DEBUG("xdpy: selected xscreen %i\n", d->xscreen);
d->is_mapped = false;
_al_cond_init(&d->mapped);
d->resize_count = 0;
d->programmatic_resize = false;
_al_xglx_config_select_visual(d);
if (!d->xvinfo) {
ALLEGRO_ERROR("FIXME: Need better visual selection.\n");
ALLEGRO_ERROR("No matching visual found.\n");
al_free(d);
al_free(ogl);
_al_mutex_unlock(&system->lock);
return NULL;
}
ALLEGRO_INFO("Selected X11 visual %lu.\n", d->xvinfo->visualid);
/* Add ourself to the list of displays. */
ALLEGRO_DISPLAY_XGLX **add;
add = _al_vector_alloc_back(&system->system.displays);
*add = d;
/* Each display is an event source. */
_al_event_source_init(&display->es);
/* Create a colormap. */
Colormap cmap = XCreateColormap(system->x11display,
RootWindow(system->x11display, d->xvinfo->screen),
d->xvinfo->visual, AllocNone);
/* Create an X11 window */
XSetWindowAttributes swa;
int mask = CWBorderPixel | CWColormap | CWEventMask;
swa.colormap = cmap;
swa.border_pixel = 0;
swa.event_mask =
KeyPressMask |
KeyReleaseMask |
StructureNotifyMask |
EnterWindowMask |
LeaveWindowMask |
FocusChangeMask |
ExposureMask |
PropertyChangeMask |
ButtonPressMask |
ButtonReleaseMask |
PointerMotionMask;
/* For a non-compositing window manager, a black background can look
* less broken if the application doesn't react to expose events fast
* enough. However in some cases like resizing, the black background
* causes horrible flicker.
*/
if (!(display->flags & ALLEGRO_RESIZABLE)) {
mask |= CWBackPixel;
swa.background_pixel = BlackPixel(system->x11display, d->xvinfo->screen);
}
int x_off = INT_MAX, y_off = INT_MAX;
if (display->flags & ALLEGRO_FULLSCREEN) {
_al_xglx_get_display_offset(system, d->adapter, &x_off, &y_off);
}
else {
/* we want new_display_adapter's offset to add to the new_window_position */
int xscr_x = 0, xscr_y = 0;
al_get_new_window_position(&x_off, &y_off);
if (adapter >= 0) {
/* non default adapter. I'm assuming this means the user wants the window to be placed on the adapter offset by new display pos */
_al_xglx_get_display_offset(system, d->adapter, &xscr_x, &xscr_y);
if (x_off != INT_MAX)
x_off += xscr_x;
if (y_off != INT_MAX)
y_off += xscr_y;
}
}
d->window = XCreateWindow(system->x11display,
RootWindow(system->x11display, d->xvinfo->screen),
x_off != INT_MAX ? x_off : 0,
y_off != INT_MAX ? y_off : 0,
w, h, 0, d->xvinfo->depth,
InputOutput, d->xvinfo->visual, mask, &swa);
// Try to set full screen mode if requested, fail if we can't
if (display->flags & ALLEGRO_FULLSCREEN) {
/* According to the spec, the window manager is supposed to disable
* window decorations when _NET_WM_STATE_FULLSCREEN is in effect.
* However, some WMs may not be fully compliant, e.g. Fluxbox.
*/
xdpy_set_frame(display, false);
_al_xglx_set_above(display, 1);
if (!_al_xglx_fullscreen_set_mode(system, d, w, h, 0, display->refresh_rate)) {
ALLEGRO_DEBUG("xdpy: failed to set fullscreen mode.\n");
xdpy_destroy_display(display);
_al_mutex_unlock(&system->lock);
return NULL;
}
//XSync(system->x11display, False);
}
if (display->flags & ALLEGRO_FRAMELESS) {
xdpy_set_frame(display, false);
}
ALLEGRO_DEBUG("X11 window created.\n");
_al_xwin_set_size_hints(display, x_off, y_off);
XLockDisplay(system->x11display);
d->wm_delete_window_atom = XInternAtom(system->x11display,
"WM_DELETE_WINDOW", False);
XSetWMProtocols(system->x11display, d->window, &d->wm_delete_window_atom, 1);
XMapWindow(system->x11display, d->window);
ALLEGRO_DEBUG("X11 window mapped.\n");
XUnlockDisplay(system->x11display);
/* Send the pending request to the X server. */
XSync(system->x11display, False);
/* To avoid race conditions where some X11 functions fail before the window
* is mapped, we wait here until it is mapped. Note that the thread is
* locked, so the event could not possibly have been processed yet in the
* events thread. So as long as no other map events occur, the condition
* should only be signalled when our window gets mapped.
*/
while (!d->is_mapped) {
_al_cond_wait(&d->mapped, &system->lock);
}
/* We can do this at any time, but if we already have a mapped
* window when switching to fullscreen it will use the same
* monitor (with the MetaCity version I'm using here right now).
*/
if ((display->flags & ALLEGRO_FULLSCREEN_WINDOW)) {
ALLEGRO_INFO("Toggling fullscreen flag for %d x %d window.\n",
display->w, display->h);
_al_xwin_reset_size_hints(display);
_al_xwin_set_fullscreen_window(display, 2);
_al_xwin_set_size_hints(display, INT_MAX, INT_MAX);
XWindowAttributes xwa;
XGetWindowAttributes(system->x11display, d->window, &xwa);
display->w = xwa.width;
display->h = xwa.height;
ALLEGRO_INFO("Using ALLEGRO_FULLSCREEN_WINDOW of %d x %d\n",
display->w, display->h);
}
if (display->flags & ALLEGRO_FULLSCREEN) {
/* kwin wants these here */
/* metacity wants these here too */
/* XXX compiz is quiky, can't seem to find a combination of hints that
* make sure we are layerd over panels, and are positioned properly */
//_al_xwin_set_fullscreen_window(display, 1);
_al_xglx_set_above(display, 1);
_al_xglx_fullscreen_to_display(system, d);
/* Grab mouse if we only have one display, ungrab it if we have more than
* one.
*/
if (_al_vector_size(&system->system.displays) == 1) {
al_grab_mouse(display);
}
else if (_al_vector_size(&system->system.displays) > 1) {
al_ungrab_mouse();
}
}
if (!_al_xglx_config_create_context(d)) {
xdpy_destroy_display(display);
_al_mutex_unlock(&system->lock);
return NULL;
}
/* Make our GLX context current for reading and writing in the current
* thread.
*/
if (d->fbc) {
if (!glXMakeContextCurrent(system->gfxdisplay, d->glxwindow,
d->glxwindow, d->context)) {
ALLEGRO_ERROR("glXMakeContextCurrent failed\n");
}
}
else {
if (!glXMakeCurrent(system->gfxdisplay, d->glxwindow, d->context)) {
ALLEGRO_ERROR("glXMakeCurrent failed\n");
}
}
_al_ogl_manage_extensions(display);
_al_ogl_set_extensions(ogl->extension_api);
/* Print out OpenGL version info */
ALLEGRO_INFO("OpenGL Version: %s\n", (const char*)glGetString(GL_VERSION));
ALLEGRO_INFO("Vendor: %s\n", (const char*)glGetString(GL_VENDOR));
ALLEGRO_INFO("Renderer: %s\n", (const char*)glGetString(GL_RENDERER));
if (display->ogl_extras->ogl_info.version < _ALLEGRO_OPENGL_VERSION_1_2) {
ALLEGRO_EXTRA_DISPLAY_SETTINGS *eds = _al_get_new_display_settings();
if (eds->required & (1<<ALLEGRO_COMPATIBLE_DISPLAY)) {
ALLEGRO_ERROR("Allegro requires at least OpenGL version 1.2 to work.\n");
xdpy_destroy_display(display);
_al_mutex_unlock(&system->lock);
return NULL;
}
display->extra_settings.settings[ALLEGRO_COMPATIBLE_DISPLAY] = 0;
}
#if 0
// Apparently, you can get a OpenGL 3.0 context without specifically creating
// it with glXCreateContextAttribsARB, and not every OpenGL 3.0 is evil, but we
// can't tell the difference at this stage.
else if (display->ogl_extras->ogl_info.version > _ALLEGRO_OPENGL_VERSION_2_1) {
/* We don't have OpenGL3 a driver. */
display->extra_settings.settings[ALLEGRO_COMPATIBLE_DISPLAY] = 0;
}
#endif
if (display->extra_settings.settings[ALLEGRO_COMPATIBLE_DISPLAY])
_al_ogl_setup_gl(display);
/* vsync */
/* Fill in the user setting. */
display->extra_settings.settings[ALLEGRO_VSYNC] =
_al_get_new_display_settings()->settings[ALLEGRO_VSYNC];
/* We set the swap interval to 0 if vsync is forced off, and to 1
* if it is forced on.
* http://www.opengl.org/registry/specs/SGI/swap_control.txt
* If the option is set to 0, we simply use the system default. The
* above extension specifies vsync on as default though, so in the
* end with GLX we can't force vsync on, just off.
*/
ALLEGRO_DEBUG("requested vsync=%d.\n",
display->extra_settings.settings[ALLEGRO_VSYNC]);
if (display->extra_settings.settings[ALLEGRO_VSYNC]) {
if (display->ogl_extras->extension_list->ALLEGRO_GLX_SGI_swap_control) {
int x = 1;
if (display->extra_settings.settings[ALLEGRO_VSYNC] == 2)
x = 0;
if (glXSwapIntervalSGI(x)) {
ALLEGRO_WARN("glXSwapIntervalSGI(%d) failed.\n", x);
}
}
else {
ALLEGRO_WARN("no vsync, GLX_SGI_swap_control missing.\n");
/* According to the specification that means it's on, but
* the driver might have disabled it. So we do not know.
*/
display->extra_settings.settings[ALLEGRO_VSYNC] = 0;
}
}
d->invisible_cursor = None; /* Will be created on demand. */
d->current_cursor = None; /* Initially, we use the root cursor. */
d->cursor_hidden = false;
d->icon = None;
d->icon_mask = None;
_al_mutex_unlock(&system->lock);
return display;
}
static ALLEGRO_DISPLAY_XGLX *xdpy_create_display_locked(
ALLEGRO_SYSTEM_XGLX *system, int flags, int w, int h, int adapter)
{
ALLEGRO_DISPLAY_XGLX *d = al_calloc(1, sizeof *d);
ALLEGRO_DISPLAY *display = (ALLEGRO_DISPLAY *)d;
ALLEGRO_OGL_EXTRAS *ogl = al_calloc(1, sizeof *ogl);
display->ogl_extras = ogl;
d->glx_version = query_glx_version(system);
display->w = w;
display->h = h;
display->vt = _al_display_xglx_driver();
display->refresh_rate = al_get_new_display_refresh_rate();
display->flags = flags;
// FIXME: default? Is this the right place to set this?
display->flags |= ALLEGRO_OPENGL;
/* Store our initial virtual adapter, used by fullscreen and positioning
* code.
*/
ALLEGRO_DEBUG("selected adapter %i\n", adapter);
if (adapter < 0)
d->adapter = _al_xglx_get_default_adapter(system);
else
d->adapter = adapter;
ALLEGRO_DEBUG("xdpy: selected adapter %i\n", d->adapter);
_al_xglx_use_adapter(system, d->adapter);
if (!check_adapter_use_count(system)) {
goto EarlyError;
}
/* Store our initial X Screen, used by window creation, fullscreen, and glx
* visual code.
*/
d->xscreen = _al_xglx_get_xscreen(system, d->adapter);
ALLEGRO_DEBUG("xdpy: selected xscreen %i\n", d->xscreen);
d->wm_delete_window_atom = None;
d->is_mapped = false;
_al_cond_init(&d->mapped);
d->is_selectioned = false;
_al_cond_init(&d->selectioned);
d->resize_count = 0;
d->programmatic_resize = false;
_al_xglx_config_select_visual(d);
if (!d->xvinfo) {
ALLEGRO_ERROR("FIXME: Need better visual selection.\n");
ALLEGRO_ERROR("No matching visual found.\n");
goto EarlyError;
}
ALLEGRO_INFO("Selected X11 visual %lu.\n", d->xvinfo->visualid);
/* Add ourself to the list of displays. */
ALLEGRO_DISPLAY_XGLX **add;
add = _al_vector_alloc_back(&system->system.displays);
*add = d;
/* Each display is an event source. */
_al_event_source_init(&display->es);
if (!xdpy_create_display_window(system, d, w, h, adapter)) {
goto LateError;
}
/* Send any pending requests to the X server.
* This is necessary to make the window ID immediately valid
* for a GtkSocket.
*/
XSync(system->x11display, False);
if (display->flags & ALLEGRO_GTK_TOPLEVEL_INTERNAL) {
ASSERT(gtk_override_vt);
if (!gtk_override_vt->create_display_hook(display, w, h)) {
goto LateError;
}
}
else {
default_overridable_vt.set_window_title(display, al_get_new_window_title());
if (!default_overridable_vt.create_display_hook(display, w, h)) {
goto LateError;
}
}
/* overridable_vt should be set by the create_display_hook. */
ASSERT(d->overridable_vt);
/* Send any pending requests to the X server. */
XSync(system->x11display, False);
/* To avoid race conditions where some X11 functions fail before the window
* is mapped, we wait here until it is mapped. Note that the thread is
* locked, so the event could not possibly have been processed yet in the
* events thread. So as long as no other map events occur, the condition
* should only be signalled when our window gets mapped.
*/
while (!d->is_mapped) {
_al_cond_wait(&d->mapped, &system->lock);
}
/* In tiling WMs, we might get resize events pretty much immediately after
* Window creation. This location seems to catch them reliably, tested with
* dwm, awesome, xmonad and i3. */
if ((display->flags & ALLEGRO_RESIZABLE) && d->resize_count > 0) {
xdpy_acknowledge_resize(display);
}
/* We can do this at any time, but if we already have a mapped
* window when switching to fullscreen it will use the same
* monitor (with the MetaCity version I'm using here right now).
*/
if ((display->flags & ALLEGRO_FULLSCREEN_WINDOW)) {
ALLEGRO_INFO("Toggling fullscreen flag for %d x %d window.\n",
display->w, display->h);
_al_xwin_reset_size_hints(display);
_al_xwin_set_fullscreen_window(display, 2);
_al_xwin_set_size_hints(display, INT_MAX, INT_MAX);
XWindowAttributes xwa;
XGetWindowAttributes(system->x11display, d->window, &xwa);
display->w = xwa.width;
display->h = xwa.height;
ALLEGRO_INFO("Using ALLEGRO_FULLSCREEN_WINDOW of %d x %d\n",
display->w, display->h);
}
if (display->flags & ALLEGRO_FULLSCREEN) {
/* kwin wants these here */
/* metacity wants these here too */
/* XXX compiz is quiky, can't seem to find a combination of hints that
* make sure we are layerd over panels, and are positioned properly */
//_al_xwin_set_fullscreen_window(display, 1);
_al_xwin_set_above(display, 1);
_al_xglx_fullscreen_to_display(system, d);
/* Grab mouse if we only have one display, ungrab it if we have more than
* one.
*/
if (_al_vector_size(&system->system.displays) == 1) {
al_grab_mouse(display);
}
else if (_al_vector_size(&system->system.displays) > 1) {
al_ungrab_mouse();
}
}
if (flags & ALLEGRO_MAXIMIZED) {
_al_xwin_maximize(display, true);
}
if (!_al_xglx_config_create_context(d)) {
goto LateError;
}
/* Make our GLX context current for reading and writing in the current
* thread.
*/
if (d->fbc) {
if (!glXMakeContextCurrent(system->gfxdisplay, d->glxwindow,
d->glxwindow, d->context)) {
ALLEGRO_ERROR("glXMakeContextCurrent failed\n");
}
}
else {
if (!glXMakeCurrent(system->gfxdisplay, d->glxwindow, d->context)) {
ALLEGRO_ERROR("glXMakeCurrent failed\n");
}
}
_al_ogl_manage_extensions(display);
_al_ogl_set_extensions(ogl->extension_api);
/* Print out OpenGL version info */
ALLEGRO_INFO("OpenGL Version: %s\n", (const char*)glGetString(GL_VERSION));
ALLEGRO_INFO("Vendor: %s\n", (const char*)glGetString(GL_VENDOR));
ALLEGRO_INFO("Renderer: %s\n", (const char*)glGetString(GL_RENDERER));
if (display->ogl_extras->ogl_info.version < _ALLEGRO_OPENGL_VERSION_1_2) {
ALLEGRO_EXTRA_DISPLAY_SETTINGS *eds = _al_get_new_display_settings();
if (eds->required & (1<<ALLEGRO_COMPATIBLE_DISPLAY)) {
ALLEGRO_ERROR("Allegro requires at least OpenGL version 1.2 to work.\n");
goto LateError;
}
display->extra_settings.settings[ALLEGRO_COMPATIBLE_DISPLAY] = 0;
}
if (display->extra_settings.settings[ALLEGRO_COMPATIBLE_DISPLAY])
_al_ogl_setup_gl(display);
/* vsync */
int vsync_setting = _al_get_new_display_settings()->settings[ALLEGRO_VSYNC];
vsync_setting = xdpy_swap_control(display, vsync_setting);
display->extra_settings.settings[ALLEGRO_VSYNC] = vsync_setting;
d->invisible_cursor = None; /* Will be created on demand. */
d->current_cursor = None; /* Initially, we use the root cursor. */
d->cursor_hidden = false;
d->icon = None;
d->icon_mask = None;
return d;
EarlyError:
al_free(d);
al_free(ogl);
return NULL;
LateError:
xdpy_destroy_display(display);
return NULL;
}
