static bool _ogl_is_extension_with_version_supported( const char *extension, ALLEGRO_DISPLAY *disp, uint32_t ver) { ALLEGRO_CONFIG *cfg; char const *value; /* For testing purposes, any OpenGL extension can be disable in * the config by using something like: * * [opengl_disabled_extensions] * GL_ARB_texture_non_power_of_two=0 * GL_EXT_framebuffer_object=0 * */ cfg = al_get_system_config(); if (cfg) { value = al_get_config_value(cfg, "opengl_disabled_extensions", extension); if (value) { ALLEGRO_WARN("%s found in [opengl_disabled_extensions].\n", extension); return false; } } /* If the extension is included in the OpenGL version, there is no * need to check the extensions list. */ if (ver > 0 && disp->ogl_extras->ogl_info.version >= ver) { return true; } return _ogl_is_extension_supported(extension, disp); }
static ALLEGRO_AUDIO_DRIVER_ENUM get_config_audio_driver(void) { ALLEGRO_CONFIG *config = al_get_system_config(); const char *value; if (!config) return ALLEGRO_AUDIO_DRIVER_AUTODETECT; value = al_get_config_value(config, "audio", "driver"); if (!value || value[0] == '\0') return ALLEGRO_AUDIO_DRIVER_AUTODETECT; if (0 == _al_stricmp(value, "ALSA")) return ALLEGRO_AUDIO_DRIVER_ALSA; if (0 == _al_stricmp(value, "OPENAL")) return ALLEGRO_AUDIO_DRIVER_OPENAL; if (0 == _al_stricmp(value, "OPENSL")) return ALLEGRO_AUDIO_DRIVER_OPENSL; if (0 == _al_stricmp(value, "OSS")) return ALLEGRO_AUDIO_DRIVER_OSS; if (0 == _al_stricmp(value, "PULSEAUDIO")) return ALLEGRO_AUDIO_DRIVER_PULSEAUDIO; if (0 == _al_stricmp(value, "DSOUND") || 0 == _al_stricmp(value, "DIRECTSOUND")) return ALLEGRO_AUDIO_DRIVER_DSOUND; return ALLEGRO_AUDIO_DRIVER_AUTODETECT; }
static ALLEGRO_DISPLAY_INTERFACE *xglx_get_display_driver(void) { ALLEGRO_SYSTEM_XGLX *system = (ALLEGRO_SYSTEM_XGLX *)al_get_system_driver(); /* Look up the toggle_mouse_grab_key binding. This isn't such a great place * to do it, but the config file is not available until after the system driver * is initialised. */ if (!system->toggle_mouse_grab_keycode) { const char *binding = al_get_config_value(al_get_system_config(), "keyboard", "toggle_mouse_grab_key"); if (binding) { system->toggle_mouse_grab_keycode = _al_parse_key_binding(binding, &system->toggle_mouse_grab_modifiers); if (system->toggle_mouse_grab_keycode) { ALLEGRO_DEBUG("Toggle mouse grab key: '%s'\n", binding); } else { ALLEGRO_WARN("Cannot parse key binding '%s'\n", binding); } } } return _al_display_xglx_driver(); }
/* Checks whether the configured joystick driver is of the given name. * Also returns false if the configuration entry was not set. */ static bool win_configured_joystick_driver_is(const char * name) { const char * driver; ALLEGRO_CONFIG * sysconf = al_get_system_config(); if (!sysconf) return false; driver = al_get_config_value(sysconf, "joystick", "driver"); if (!driver) return false; ALLEGRO_DEBUG("Configuration value joystick.driver = %s\n", driver); return (0 == _al_stricmp(driver, name)); }
static void dsound_set_buffer_size(int bits_per_sample) { int buffer_size_in_samples = 8192; // default const char *val = al_get_config_value(al_get_system_config(), "directsound", "buffer_size"); if (val && val[0] != '\0') { int n = atoi(val); if (n < MIN_BUFFER_SIZE) n = MIN_BUFFER_SIZE; buffer_size_in_samples = n; } buffer_size = buffer_size_in_samples * (bits_per_sample/8); }
static HWND get_window() { const char *val = al_get_config_value(al_get_system_config(), "directsound", "window"); HWND ret; if (val && strncmp(val, "foreground", 10) == 0) { ret = GetForegroundWindow(); ALLEGRO_INFO("Using foreground window: %p\n", ret); } else { ret = GetDesktopWindow(); ALLEGRO_INFO("Using desktop window: %p\n", ret); } return ret; }
static void dsound_set_buffer_size(int bits_per_sample) { ALLEGRO_CONFIG *config = al_get_system_config(); if (config) { const char *val = al_get_config_value(config, "directsound", "buffer_size"); if (val && val[0] != '\0') { int n = atoi(val); if (n < MIN_BUFFER_SIZE) n = MIN_BUFFER_SIZE; buffer_size_in_samples = n; } } buffer_size = buffer_size_in_samples * (bits_per_sample/8); }
static bool ljoy_detect_device_name(int num, ALLEGRO_USTR *device_name) { char key[80]; const char *value; struct stat stbuf; al_ustr_truncate(device_name, 0); snprintf(key, sizeof(key), "device%d", num); value = al_get_config_value(al_get_system_config(), "joystick", key); if (value) al_ustr_assign_cstr(device_name, value); if (al_ustr_size(device_name) == 0) al_ustr_appendf(device_name, "/dev/input/event%d", num); return (stat(al_cstr(device_name), &stbuf) == 0); }
/* Reads version info out of glGetString(GL_VERSION) */ static uint32_t _al_ogl_version(void) { #if !defined ALLEGRO_IPHONE && !defined ALLEGRO_ANDROID ALLEGRO_CONFIG *cfg; const char *str; cfg = al_get_system_config(); if (cfg) { char const *value = al_get_config_value(cfg, "opengl", "force_opengl_version"); if (value) { uint32_t v = parse_opengl_version(value); ALLEGRO_INFO("OpenGL version forced to %d.%d.%d.%d.\n", (v >> 24) & 0xff, (v >> 16) & 0xff, (v >> 8) & 0xff, (v & 0xff)); return v; } } str = (const char *)glGetString(GL_VERSION); if (str) { return parse_opengl_version(str); } else { /* The OpenGL driver does not return a version * number. However it probably supports at least OpenGL 1.0 */ return _ALLEGRO_OPENGL_VERSION_1_0; } #else /* XXX this is asking for trouble, and should be documented */ const char *s = (char *)glGetString(GL_VERSION); if (strstr(s, "2.0")) return _ALLEGRO_OPENGL_VERSION_2_0; else if (strstr(s, "1.1")) return _ALLEGRO_OPENGL_VERSION_1_1; else return _ALLEGRO_OPENGL_VERSION_0; #endif }
static int oss_open_ver3(void) { ALLEGRO_CONFIG *config = al_get_system_config(); if (config) { const char *config_device; config_device = al_get_config_value(config, "oss", "device"); if (config_device && config_device[0] != '\0') oss_audio_device_ver3 = config_device; } int fd = open(oss_audio_device_ver3, O_WRONLY); if (fd == -1) { switch (errno) { case ENXIO: case ENODEV: ALLEGRO_ERROR("Open Sound System is not running in your " "system.\n"); break; case ENOENT: ALLEGRO_ERROR("No '%s' device available in your system.\n", oss_audio_device_ver3); ALLEGRO_ERROR("Perhaps Open Sound System is not installed " "or running.\n"); break; default: ALLEGRO_ERROR("errno: %i -- %s\n", errno, strerror(errno)); } return 1; } close(fd); strncpy(oss_audio_device, oss_audio_device_ver3, 512); ALLEGRO_INFO("Using device: %s\n", oss_audio_device); using_ver_4 = false; return 0; }
static int oss_open(void) { bool force_oss3 = false; ALLEGRO_CONFIG *config = al_get_system_config(); if (config) { const char *force_oss3_cfg; force_oss3_cfg = al_get_config_value(config, "oss", "force_ver3"); if (force_oss3_cfg && force_oss3_cfg[0] != '\0') force_oss3 = strcmp(force_oss3_cfg, "yes") ? false : true; } if (force_oss3) { ALLEGRO_WARN("Skipping OSS4 probe.\n"); } #ifdef OSS_VER_4 bool inited = false; if (!force_oss3) { if (oss_open_ver4()) ALLEGRO_WARN("OSS ver. 4 init failed, trying ver. 3...\n"); else inited = true; } if (!inited && oss_open_ver3()) { ALLEGRO_ERROR("Failed to init OSS.\n"); return 1; } #else ALLEGRO_INFO("OSS4 support not compiled in. Skipping OSS4 probe.\n"); if (oss_open_ver3()) { ALLEGRO_ERROR("Failed to init OSS.\n"); return 1; } #endif return 0; }
/* Creates the default voice and mixer if they haven't been created yet. */ static bool create_default_mixer(void) { int voice_frequency = 44100; int voice_depth = ALLEGRO_AUDIO_DEPTH_INT16; int mixer_frequency = 44100; int mixer_depth = ALLEGRO_AUDIO_DEPTH_FLOAT32; ALLEGRO_CONFIG *config = al_get_system_config(); const char *p; p = al_get_config_value(config, "audio", "primary_voice_frequency"); if (p && p[0] != '\0') { voice_frequency = atoi(p); } p = al_get_config_value(config, "audio", "primary_mixer_frequency"); if (p && p[0] != '\0') { mixer_frequency = atoi(p); } p = al_get_config_value(config, "audio", "primary_voice_depth"); if (p && p[0] != '\0') { voice_depth = string_to_depth(p); } p = al_get_config_value(config, "audio", "primary_mixer_depth"); if (p && p[0] != '\0') { mixer_depth = string_to_depth(p); } if (!allegro_voice) { allegro_voice = al_create_voice(voice_frequency, voice_depth, ALLEGRO_CHANNEL_CONF_2); if (!allegro_voice) { ALLEGRO_ERROR("al_create_voice failed\n"); goto Error; } } if (!allegro_mixer) { allegro_mixer = al_create_mixer(mixer_frequency, mixer_depth, ALLEGRO_CHANNEL_CONF_2); if (!allegro_mixer) { ALLEGRO_ERROR("al_create_voice failed\n"); goto Error; } } /* In case this function is called multiple times. */ al_detach_mixer(allegro_mixer); if (!al_attach_mixer_to_voice(allegro_mixer, allegro_voice)) { ALLEGRO_ERROR("al_attach_mixer_to_voice failed\n"); goto Error; } return true; Error: if (allegro_mixer) { al_destroy_mixer(allegro_mixer); allegro_mixer = NULL; } if (allegro_voice) { al_destroy_voice(allegro_voice); allegro_voice = NULL; } return false; }
static ALLEGRO_DISPLAY_INTERFACE *win_get_display_driver(void) { const int flags = al_get_new_display_flags(); ALLEGRO_SYSTEM *sys = al_get_system_driver(); ALLEGRO_CONFIG *sys_cfg = al_get_system_config(); ALLEGRO_SYSTEM_WIN *syswin = (ALLEGRO_SYSTEM_WIN *)sys; const char *s; /* Look up the toggle_mouse_grab_key binding. This isn't such a great place * to do it, but the config file is not available in win_initialize, * and this is neutral between the D3D and OpenGL display drivers. */ if (!syswin->toggle_mouse_grab_keycode) { const char *binding = al_get_config_value(sys_cfg, "keyboard", "toggle_mouse_grab_key"); if (binding) { syswin->toggle_mouse_grab_keycode = _al_parse_key_binding(binding, &syswin->toggle_mouse_grab_modifiers); if (syswin->toggle_mouse_grab_keycode) { ALLEGRO_DEBUG("Toggle mouse grab key: '%s'\n", binding); } else { ALLEGRO_WARN("Cannot parse key binding '%s'\n", binding); } } } /* Programmatic selection. */ #ifdef ALLEGRO_CFG_D3D if (flags & ALLEGRO_DIRECT3D_INTERNAL) { ALLEGRO_DISPLAY_INTERFACE* iface = _al_display_d3d_driver(); if (iface == NULL) ALLEGRO_WARN("Direct3D graphics driver not available.\n"); return iface; } #endif #ifdef ALLEGRO_CFG_OPENGL if (flags & ALLEGRO_OPENGL) { return _al_display_wgl_driver(); } #endif /* Selection by configuration file. The configuration value is non-binding. * The user may unknowingly set a value which was configured out at compile * time. The value should have no effect instead of causing a failure. */ s = al_get_config_value(sys_cfg, "graphics", "driver"); if (s) { ALLEGRO_DEBUG("Configuration value graphics.driver = %s\n", s); if (0 == _al_stricmp(s, "DIRECT3D") || 0 == _al_stricmp(s, "D3D")) { #ifdef ALLEGRO_CFG_D3D ALLEGRO_DISPLAY_INTERFACE* iface = _al_display_d3d_driver(); if (iface != NULL) { al_set_new_display_flags(flags | ALLEGRO_DIRECT3D_INTERNAL); return iface; } #endif } else if (0 == _al_stricmp(s, "OPENGL")) { #ifdef ALLEGRO_CFG_OPENGL al_set_new_display_flags(flags | ALLEGRO_OPENGL); return _al_display_wgl_driver(); #endif } else if (0 != _al_stricmp(s, "DEFAULT")) { ALLEGRO_WARN("Graphics driver selection unrecognised: %s\n", s); } } /* Automatic graphics driver selection. */ /* XXX is implicitly setting new_display_flags the desired behaviour? */ #ifdef ALLEGRO_CFG_D3D { ALLEGRO_DISPLAY_INTERFACE* iface = _al_display_d3d_driver(); if (iface != NULL) { al_set_new_display_flags(flags | ALLEGRO_DIRECT3D_INTERNAL); return iface; } } #endif #ifdef ALLEGRO_CFG_OPENGL { al_set_new_display_flags(flags | ALLEGRO_OPENGL); return _al_display_wgl_driver(); } #endif ALLEGRO_WARN("No graphics driver available.\n"); return NULL; }
/* Function: al_set_display_menu */ bool al_set_display_menu(ALLEGRO_DISPLAY *display, ALLEGRO_MENU *menu) { DISPLAY_MENU *dm = NULL; size_t i; int menu_height = _al_get_menu_display_height(); bool automatic_menu_display_resize = true; const char* automatic_menu_display_resize_value = al_get_config_value(al_get_system_config(), "compatibility", "automatic_menu_display_resize"); if (automatic_menu_display_resize_value && strcmp(automatic_menu_display_resize_value, "false") == 0) automatic_menu_display_resize = false; ASSERT(display); /* Check if this display has a menu associated with it */ for (i = 0; i < _al_vector_size(&display_menus); ++i) { dm = (DISPLAY_MENU *) _al_vector_ref(&display_menus, i); if (dm->display == display) break; } /* If no display was found, reset dm to NULL */ if (i == _al_vector_size(&display_menus)) dm = NULL; if (!menu) { /* Removing the menu */ if (!dm) return false; _al_hide_display_menu(display, dm->menu); _al_walk_over_menu(dm->menu, set_menu_display_r, NULL); _al_vector_delete_at(&display_menus, i); if (automatic_menu_display_resize && menu_height > 0) { display->extra_resize_height = 0; al_resize_display(display, al_get_display_width(display), al_get_display_height(display)); } } else { /* Setting the menu. It must not currently be attached to any * display, and it cannot have a parent menu. */ if (menu->display || menu->parent) return false; if (dm) { /* hide the existing menu */ _al_hide_display_menu(display, dm->menu); _al_walk_over_menu(dm->menu, set_menu_display_r, NULL); } if (!_al_show_display_menu(display, menu)) { /* Unable to set the new menu, but already have hidden the * previous one, so delete the display_menus slot. */ if (dm) _al_vector_delete_at(&display_menus, i); return false; } /* Set the entire menu tree as owned by the display */ _al_walk_over_menu(menu, set_menu_display_r, display); if (!dm) dm = _al_vector_alloc_back(&display_menus); if (automatic_menu_display_resize && menu_height > 0) { /* Temporarily disable the constraints so we don't send a RESIZE_EVENT. */ bool old_constraints = display->use_constraints; display->use_constraints = false; display->extra_resize_height = menu_height; al_resize_display(display, al_get_display_width(display), al_get_display_height(display)); display->use_constraints = old_constraints; } dm->display = display; dm->menu = menu; } return true; }
static bool _al_xwin_get_keyboard_mapping(void) { int i; int count; int missing = 0; ALLEGRO_SYSTEM_XGLX *system = (void *)al_get_system_driver(); memset(used, 0, sizeof used); memset(keycode_to_scancode, 0, sizeof keycode_to_scancode); XDisplayKeycodes(system->x11display, &min_keycode, &max_keycode); count = 1 + max_keycode - min_keycode; if (keysyms) { XFree(keysyms); } keysyms = XGetKeyboardMapping(system->x11display, min_keycode, count, &sym_per_key); ALLEGRO_INFO("%i keys, %i symbols per key.\n", count, sym_per_key); if (sym_per_key <= 0) { return false; } missing = 0; for (i = min_keycode; i <= max_keycode; i++) { KeySym sym = keysyms[sym_per_key * (i - min_keycode)]; KeySym sym2 = keysyms[sym_per_key * (i - min_keycode) + 1]; char *sym_str, *sym2_str; int allegro_key = 0; char str[1024]; sym_str = XKeysymToString(sym); sym2_str = XKeysymToString(sym2); snprintf(str, sizeof str, "key [%i: %s %s]", i, sym_str ? sym_str : "NULL", sym2_str ? sym2_str : "NULL"); /* Hack for French keyboards, to correctly map ALLEGRO_KEY_0 to ALLEGRO_KEY_9. */ if (sym2 >= XK_0 && sym2 <= XK_9) { allegro_key = find_allegro_key(sym2); } if (!allegro_key) { if (sym != NoSymbol) { allegro_key = find_allegro_key(sym); if (allegro_key == 0) { missing++; ALLEGRO_DEBUG("%s defering.\n", str); } } else { /* No KeySym for this key - ignore it. */ keycode_to_scancode[i] = -1; ALLEGRO_DEBUG("%s not assigned.\n", str); } } if (allegro_key) { bool is_double = false; if (used[allegro_key]) { is_double = true; } keycode_to_scancode[i] = allegro_key; key_names[allegro_key] = XKeysymToString(keysyms[sym_per_key * (i - min_keycode)]); used[allegro_key] = 1; ALLEGRO_DEBUG("%s%s assigned to %i.\n", str, is_double ? " *double*" : "", allegro_key); } } if (missing) { /* The keys still not assigned are just assigned arbitrarily now. */ for (i = min_keycode; i <= max_keycode; i++) { if (keycode_to_scancode[i] == 0) { find_unknown_key_assignment(i); } } } if (xmodmap) XFreeModifiermap(xmodmap); xmodmap = XGetModifierMapping(system->x11display); for (i = 0; i < 8; i++) { int j; char str[1024]; sprintf(str, "Modifier %d:", i + 1); for (j = 0; j < xmodmap->max_keypermod; j++) { KeyCode keycode = xmodmap->modifiermap[i * xmodmap->max_keypermod + j]; // XKeycodeToKeysym is deprecated //KeySym sym = XKeycodeToKeysym(system->x11display, keycode, 0); KeySym sym = XkbKeycodeToKeysym(system->x11display, keycode, 0, 0); char *sym_str = XKeysymToString(sym); sprintf(str + strlen(str), " %s", sym_str ? sym_str : "NULL"); } ALLEGRO_DEBUG("%s\n", str); } /* The [xkeymap] section can be useful, e.g. if trying to play a * game which has X and Y hardcoded as ALLEGRO_KEY_X and ALLEGRO_KEY_Y to mean * left/right movement, but on the X11 keyboard X and Y are far apart. * For normal use, a user never should have to touch [xkeymap] anymore * though, and proper written programs will not hardcode such mappings. */ ALLEGRO_CONFIG *c = al_get_system_config(); char const *key; ALLEGRO_CONFIG_ENTRY *it; key = al_get_first_config_entry(c, "xkeymap", &it); while (key) { char const *val; val = al_get_config_value(c, "xkeymap", key); int keycode = strtol(key, NULL, 10); int scancode = strtol(val, NULL, 10); if (keycode > 0 && scancode > 0) { keycode_to_scancode[keycode] = scancode; ALLEGRO_WARN("User override: KeySym %i assigned to %i.\n", keycode, scancode); } key = al_get_next_config_entry(&it); } return true; }
static int pulseaudio_allocate_voice(ALLEGRO_VOICE *voice) { PULSEAUDIO_VOICE *pv = al_malloc(sizeof(PULSEAUDIO_VOICE)); pa_sample_spec ss; pa_buffer_attr ba; ss.channels = al_get_channel_count(voice->chan_conf); ss.rate = voice->frequency; if (voice->depth == ALLEGRO_AUDIO_DEPTH_UINT8) ss.format = PA_SAMPLE_U8; else if (voice->depth == ALLEGRO_AUDIO_DEPTH_INT16) ss.format = PA_SAMPLE_S16NE; #if PA_API_VERSION > 11 else if (voice->depth == ALLEGRO_AUDIO_DEPTH_INT24) ss.format = PA_SAMPLE_S24NE; #endif else if (voice->depth == ALLEGRO_AUDIO_DEPTH_FLOAT32) ss.format = PA_SAMPLE_FLOAT32NE; else { ALLEGRO_ERROR("Unsupported PulseAudio sound format.\n"); al_free(pv); return 1; } ba.maxlength = 0x10000; // maximum length of buffer ba.tlength = 0x2000; // target length of buffer ba.prebuf = -1; // minimum data size required before playback starts // set to -1 to work with the simple API. ba.minreq = 0; // minimum size of request ba.fragsize = -1; // fragment size (recording) pv->s = pa_simple_new( NULL, // Use the default server. al_get_app_name(), PA_STREAM_PLAYBACK, NULL, // Use the default device. "Allegro Voice", &ss, NULL, // Use default channel map &ba, NULL // Ignore error code. ); if (!pv->s) { al_free(pv); return 1; } voice->extra = pv; pv->buffer_size_in_frames = get_buffer_size(al_get_system_config()); pv->frame_size_in_bytes = ss.channels * al_get_audio_depth_size(voice->depth); pv->status = PV_IDLE; //pv->status_mutex = al_create_mutex(); pv->status_cond = al_create_cond(); pv->buffer_mutex = al_create_mutex(); pv->poll_thread = al_create_thread(pulseaudio_update, (void*)voice); al_start_thread(pv->poll_thread); return 0; }
/* 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_SYSTEM *xglx_initialize(int flags) { Display *x11display; Display *gfxdisplay; ALLEGRO_SYSTEM_XGLX *s; (void)flags; #ifdef DEBUG_X11 _Xdebug = 1; #endif XInitThreads(); /* Get an X11 display handle. */ x11display = XOpenDisplay(0); if (x11display) { /* Never ask. */ gfxdisplay = XOpenDisplay(0); if (!gfxdisplay) { ALLEGRO_ERROR("XOpenDisplay failed second time.\n"); XCloseDisplay(x11display); return NULL; } } else { ALLEGRO_INFO("XOpenDisplay failed; assuming headless mode.\n"); gfxdisplay = NULL; } _al_unix_init_time(); s = al_calloc(1, sizeof *s); _al_mutex_init_recursive(&s->lock); _al_cond_init(&s->resized); s->inhibit_screensaver = false; _al_vector_init(&s->system.displays, sizeof (ALLEGRO_DISPLAY_XGLX *)); s->system.vt = xglx_vt; s->gfxdisplay = gfxdisplay; s->x11display = x11display; if (s->x11display) { ALLEGRO_INFO("XGLX driver connected to X11 (%s %d).\n", ServerVendor(s->x11display), VendorRelease(s->x11display)); ALLEGRO_INFO("X11 protocol version %d.%d.\n", ProtocolVersion(s->x11display), ProtocolRevision(s->x11display)); /* We need to put *some* atom into the ClientMessage we send for * faking mouse movements with al_set_mouse_xy - so let's ask X11 * for one here. */ s->AllegroAtom = XInternAtom(x11display, "AllegroAtom", False); /* Message type for XEmbed protocol. */ s->XEmbedAtom = XInternAtom(x11display, "_XEMBED", False); _al_thread_create(&s->xevents_thread, _al_xwin_background_thread, s); s->have_xevents_thread = true; ALLEGRO_INFO("events thread spawned.\n"); } const char *binding = al_get_config_value(al_get_system_config(), "keyboard", "toggle_mouse_grab_key"); if (binding) { s->toggle_mouse_grab_keycode = _al_parse_key_binding(binding, &s->toggle_mouse_grab_modifiers); if (s->toggle_mouse_grab_keycode) { ALLEGRO_DEBUG("Toggle mouse grab key: '%s'\n", binding); } else { ALLEGRO_WARN("Cannot parse key binding '%s'\n", binding); } } #ifdef ALLEGRO_XWINDOWS_WITH_XPM x11_xpm = icon_xpm; #endif return &s->system; }