void serial_module_init()
{
#ifndef ALLEGRO_WINDOWS
dzcomm_init();
#endif
serial_timer_running = FALSE;
/* all variables and code used inside interrupt handlers must be locked */
LOCK_VARIABLE(serial_time_out);
LOCK_FUNCTION(serial_time_out_handler);
_add_exit_func(serial_module_shutdown, "serial_module_shutdown");
}
/* _register_font_file_type_init:
* Register built-in font file types.
*/
void _register_font_file_type_init(void)
{
char buf[32];
_add_exit_func(register_font_file_type_exit,
"register_font_file_type_exit");
register_font_file_type(uconvert_ascii("dat", buf), load_dat_font);
register_font_file_type(uconvert_ascii("fnt", buf), load_grx_or_bios_font);
register_font_file_type(uconvert_ascii("txt", buf), load_txt_font);
}
/* init_irq:
* Reads the default hardware interrupt masks.
*/
static void init_irq(void)
{
if (pic_virgin) {
default_pic1 = inportb(0x21);
default_pic2 = inportb(0xA1);
altered_pic1 = 0;
altered_pic2 = 0;
_add_exit_func(exit_irq, "exit_irq");
pic_virgin = FALSE;
}
}
/* install_joystick:
* Initialises the joystick module.
*/
int install_joystick(int type)
{
int c;
if (_joystick_installed)
return 0;
clear_joystick_vars();
allegro_error[0] = 0;
/* search table for a specific driver */
for (c=0; _joystick_driver_list[c].driver; c++) {
if (_joystick_driver_list[c].driver_id == type) {
joystick_driver = _joystick_driver_list[c].driver;
joy_type = type;
if (joystick_driver->init() != 0) {
if (!allegro_error[0])
sprintf(allegro_error, get_config_text("%s not found"), joystick_driver->name);
joystick_driver = NULL;
joy_type = JOY_TYPE_NONE;
return -1;
}
break;
}
}
/* autodetect driver */
if (!joystick_driver) {
if (!joy_loading) {
if (load_joystick_data(NULL) == 0)
return 0;
}
for (c=0; _joystick_driver_list[c].driver; c++) {
if (_joystick_driver_list[c].autodetect) {
joystick_driver = _joystick_driver_list[c].driver;
joy_type = _joystick_driver_list[c].driver_id;
if (_joystick_driver_list[c].driver->init() == 0)
break;
}
}
}
for (c=0; c<num_joysticks; c++)
update_calib(c);
poll_joystick();
_add_exit_func(remove_joystick);
_joystick_installed = TRUE;
return 0;
}
/* _register_bitmap_file_type_init:
* Register built-in bitmap file types.
*/
void _register_bitmap_file_type_init(void)
{
char buf[32];
_add_exit_func(register_bitmap_file_type_exit,
"register_bitmap_file_type_exit");
register_bitmap_file_type(uconvert_ascii("bmp", buf), load_bmp, save_bmp);
register_bitmap_file_type(uconvert_ascii("lbm", buf), load_lbm, NULL);
register_bitmap_file_type(uconvert_ascii("pcx", buf), load_pcx, save_pcx);
register_bitmap_file_type(uconvert_ascii("tga", buf), load_tga, save_tga);
}
/* _set_gfx_mode:
* Called by set_gfx_mode(). Separated to make a clear difference between
* the virtual GFX_SAFE driver and the rest. The allow_config parameter,
* if true, allows the configuration to override the graphics card/driver
* when using GFX_AUTODETECT.
*/
static int _set_gfx_mode(int card, int w, int h, int v_w, int v_h, int allow_config)
{
_DRIVER_INFO *driver_list;
GFX_DRIVER *drv;
char tmp1[64], tmp2[64];
AL_CONST char *dv;
int flags = 0;
int c;
ASSERT(system_driver);
ASSERT(card != GFX_SAFE);
/* remember the current console state */
if (gfx_virgin) {
TRACE(PREFIX_I "First call, remembering console state.\n");
LOCK_FUNCTION(_stub_bank_switch);
LOCK_FUNCTION(blit);
if (system_driver->save_console_state)
system_driver->save_console_state();
_add_exit_func(shutdown_gfx, "shutdown_gfx");
gfx_virgin = FALSE;
}
timer_simulate_retrace(FALSE);
_screen_split_position = 0;
/* close down any existing graphics driver */
if (gfx_driver) {
TRACE(PREFIX_I "Closing graphics driver (%p) ", gfx_driver);
TRACE("%s.\n", gfx_driver->ascii_name);
if (_al_linker_mouse)
_al_linker_mouse->show_mouse(NULL);
while (vram_bitmap_list)
destroy_bitmap(vram_bitmap_list->bmp);
bmp_read_line(screen, 0);
bmp_write_line(screen, 0);
bmp_unwrite_line(screen);
if (gfx_driver->scroll)
gfx_driver->scroll(0, 0);
if (gfx_driver->exit)
gfx_driver->exit(screen);
destroy_bitmap(screen);
gfx_driver = NULL;
screen = NULL;
gfx_capabilities = 0;
}
/* We probably don't want to do this because it makes
* Allegro "forget" the color layout of previously set
* graphics modes. But it should be retained if bitmaps
* created in those modes are to be used in the new mode.
*/
#if 0
/* restore default truecolor pixel format */
_rgb_r_shift_15 = 0;
_rgb_g_shift_15 = 5;
_rgb_b_shift_15 = 10;
_rgb_r_shift_16 = 0;
_rgb_g_shift_16 = 5;
_rgb_b_shift_16 = 11;
_rgb_r_shift_24 = 0;
_rgb_g_shift_24 = 8;
_rgb_b_shift_24 = 16;
_rgb_r_shift_32 = 0;
_rgb_g_shift_32 = 8;
_rgb_b_shift_32 = 16;
_rgb_a_shift_32 = 24;
#endif
gfx_capabilities = 0;
_set_current_refresh_rate(0);
/* return to text mode? */
if (card == GFX_TEXT) {
TRACE(PREFIX_I "Closing, restoring original console state.\n");
if (system_driver->restore_console_state)
system_driver->restore_console_state();
if (_gfx_bank) {
_AL_FREE(_gfx_bank);
_gfx_bank = NULL;
}
TRACE(PREFIX_I "Graphic mode closed.\n");
return 0;
}
/* now to the interesting part: let's try to find a graphics driver */
usetc(allegro_error, 0);
/* ask the system driver for a list of graphics hardware drivers */
if (system_driver->gfx_drivers)
driver_list = system_driver->gfx_drivers();
else
driver_list = _gfx_driver_list;
/* filter specific fullscreen/windowed driver requests */
if (card == GFX_AUTODETECT_FULLSCREEN) {
flags |= GFX_DRIVER_FULLSCREEN_FLAG;
card = GFX_AUTODETECT;
}
else if (card == GFX_AUTODETECT_WINDOWED) {
flags |= GFX_DRIVER_WINDOWED_FLAG;
card = GFX_AUTODETECT;
}
if (card == GFX_AUTODETECT) {
/* autodetect the driver */
int found = FALSE;
tmp1[0] = '\0';
/* first try the config variables */
if (allow_config) {
/* try the gfx_card variable if GFX_AUTODETECT or GFX_AUTODETECT_FULLSCREEN was selected */
if (!(flags & GFX_DRIVER_WINDOWED_FLAG))
found = get_config_gfx_driver(uconvert_ascii("gfx_card", tmp1), w, h, v_w, v_h, flags, driver_list);
/* try the gfx_cardw variable if GFX_AUTODETECT or GFX_AUTODETECT_WINDOWED was selected */
if (!(flags & GFX_DRIVER_FULLSCREEN_FLAG) && !found)
found = get_config_gfx_driver(uconvert_ascii("gfx_cardw", tmp1), w, h, v_w, v_h, flags, driver_list);
}
/* go through the list of autodetected drivers if none was previously found */
if (!found) {
TRACE(PREFIX_I "Autodetecting graphic driver.\n");
for (c=0; driver_list[c].driver; c++) {
if (driver_list[c].autodetect) {
drv = driver_list[c].driver;
if (gfx_driver_is_valid(drv, flags)) {
screen = init_gfx_driver(drv, w, h, v_w, v_h);
if (screen)
break;
}
}
}
}
else {
TRACE(PREFIX_I "GFX_AUTODETECT overridden through configuration:"
" %s.\n", tmp1);
}
}
else {
/* search the list for the requested driver */
drv = get_gfx_driver_from_id(card, driver_list);
if (drv)
screen = init_gfx_driver(drv, w, h, v_w, v_h);
}
/* gracefully handle failure */
if (!screen) {
gfx_driver = NULL; /* set by init_gfx_driver() */
if (!ugetc(allegro_error))
ustrzcpy(allegro_error, ALLEGRO_ERROR_SIZE, get_config_text("Unable to find a suitable graphics driver"));
TRACE(PREFIX_E "Failed setting graphic driver %d.\n", card);
return -1;
}
/* set the basic capabilities of the driver */
if ((VIRTUAL_W > SCREEN_W) || (VIRTUAL_H > SCREEN_H)) {
if (gfx_driver->scroll)
gfx_capabilities |= GFX_CAN_SCROLL;
if ((gfx_driver->request_scroll) || (gfx_driver->request_video_bitmap))
gfx_capabilities |= GFX_CAN_TRIPLE_BUFFER;
}
/* check whether we are instructed to disable vsync */
dv = get_config_string(uconvert_ascii("graphics", tmp1),
uconvert_ascii("disable_vsync", tmp2),
NULL);
if ((dv) && ((c = ugetc(dv)) != 0) && ((c == 'y') || (c == 'Y') || (c == '1')))
_wait_for_vsync = FALSE;
else
_wait_for_vsync = TRUE;
TRACE(PREFIX_I "The driver %s wait for vsync.\n",
(_wait_for_vsync) ? "will" : "won't");
/* Give the gfx driver an opportunity to set the drawing mode */
if ((gfx_driver->drawing_mode) && (!_dispsw_status))
gfx_driver->drawing_mode();
clear_bitmap(screen);
/* set up the default colors */
for (c=0; c<256; c++)
_palette_color8[c] = c;
set_palette(default_palette);
if (_al_linker_mouse)
_al_linker_mouse->set_mouse_etc();
LOCK_DATA(gfx_driver, sizeof(GFX_DRIVER));
_register_switch_bitmap(screen, NULL);
TRACE(PREFIX_I "set_gfx_card success for %dx%dx%d.\n",
screen->w, screen->h, bitmap_color_depth(screen));
return 0;
}
/* install_mouse:
* Installs the Allegro mouse handler. You must do this before using any
* other mouse functions. Return -1 if it can't find a mouse driver,
* otherwise the number of buttons on the mouse.
*/
int install_mouse(void)
{
_DRIVER_INFO *driver_list;
int num_buttons = -1;
int config_num_buttons;
AL_CONST char *emulate;
char tmp1[64], tmp2[64];
int i;
if (mouse_driver)
return 0;
LOCK_VARIABLE(mouse_driver);
LOCK_VARIABLE(mousedrv_none);
LOCK_VARIABLE(mouse_x);
LOCK_VARIABLE(mouse_y);
LOCK_VARIABLE(mouse_z);
LOCK_VARIABLE(mouse_w);
LOCK_VARIABLE(mouse_b);
LOCK_VARIABLE(mouse_pos);
LOCK_VARIABLE(_mouse_x);
LOCK_VARIABLE(_mouse_y);
LOCK_VARIABLE(_mouse_z);
LOCK_VARIABLE(_mouse_w);
LOCK_VARIABLE(_mouse_b);
LOCK_VARIABLE(_mouse_on);
LOCK_VARIABLE(mon);
LOCK_VARIABLE(emulate_three);
LOCK_VARIABLE(freeze_mouse_flag);
LOCK_VARIABLE(mouse_callback);
LOCK_VARIABLE(mouse_x_focus);
LOCK_VARIABLE(mouse_y_focus);
LOCK_VARIABLE(mouse_sprite);
LOCK_VARIABLE(_mouse_pointer);
LOCK_VARIABLE(_mouse_screen);
LOCK_VARIABLE(mx);
LOCK_VARIABLE(my);
LOCK_VARIABLE(ms);
LOCK_VARIABLE(mtemp);
LOCK_VARIABLE(mouse_polled);
LOCK_VARIABLE(mouse_semaphore);
LOCK_VARIABLE(cursors);
LOCK_FUNCTION(draw_mouse_doublebuffer);
LOCK_FUNCTION(draw_mouse);
LOCK_FUNCTION(update_mouse);
LOCK_FUNCTION(mouse_move);
LOCK_FUNCTION(poll_mouse);
LOCK_FUNCTION(mouse_needs_poll);
LOCK_FUNCTION(_handle_mouse_input);
/* Construct mouse pointers */
if (!default_cursors[MOUSE_CURSOR_ARROW])
default_cursors[MOUSE_CURSOR_ARROW] = create_mouse_pointer(mouse_arrow_data);
if (!default_cursors[MOUSE_CURSOR_BUSY])
default_cursors[MOUSE_CURSOR_BUSY] = create_mouse_pointer(mouse_busy_data);
if (!default_cursors[MOUSE_CURSOR_QUESTION])
default_cursors[MOUSE_CURSOR_QUESTION] = create_mouse_pointer(mouse_arrow_data);
if (!default_cursors[MOUSE_CURSOR_EDIT])
default_cursors[MOUSE_CURSOR_EDIT] = create_mouse_pointer(mouse_arrow_data);
cursors[MOUSE_CURSOR_ARROW] = default_cursors[MOUSE_CURSOR_ARROW];
cursors[MOUSE_CURSOR_BUSY] = default_cursors[MOUSE_CURSOR_BUSY];
cursors[MOUSE_CURSOR_QUESTION] = default_cursors[MOUSE_CURSOR_QUESTION];
cursors[MOUSE_CURSOR_EDIT] = default_cursors[MOUSE_CURSOR_EDIT];
if (system_driver->mouse_drivers)
driver_list = system_driver->mouse_drivers();
else
driver_list = _mouse_driver_list;
if (_mouse_type == MOUSEDRV_AUTODETECT)
_mouse_type = get_config_id(uconvert_ascii("mouse", tmp1), uconvert_ascii("mouse", tmp2), MOUSEDRV_AUTODETECT);
if (_mouse_type != MOUSEDRV_AUTODETECT) {
for (i=0; driver_list[i].driver; i++) {
if (driver_list[i].id == _mouse_type) {
mouse_driver = driver_list[i].driver;
break;
}
}
}
if (mouse_driver) {
mouse_driver->name = mouse_driver->desc = get_config_text(mouse_driver->ascii_name);
num_buttons = mouse_driver->init();
}
else {
for (i=0; num_buttons<0; i++) {
if (!driver_list[i].driver)
break;
mouse_driver = driver_list[i].driver;
mouse_driver->name = mouse_driver->desc = get_config_text(mouse_driver->ascii_name);
num_buttons = mouse_driver->init();
}
}
if (num_buttons < 0) {
mouse_driver = NULL;
return -1;
}
config_num_buttons = get_config_int(uconvert_ascii("mouse", tmp1), uconvert_ascii("num_buttons", tmp2), -1);
emulate = get_config_string(uconvert_ascii("mouse", tmp1), uconvert_ascii("emulate_three", tmp2), NULL);
/* clamp config_num_buttons to zero/positive values */
if (config_num_buttons >= 0)
num_buttons = config_num_buttons;
if ((emulate) && ((i = ugetc(emulate)) != 0)) {
if ((i == 'y') || (i == 'Y') || (i == '1'))
emulate_three = TRUE;
else
emulate_three = FALSE;
}
else {
emulate_three = FALSE;
}
mouse_polled = (mouse_driver->poll) ? TRUE : FALSE;
_mouse_installed = TRUE;
disable_hardware_cursor();
set_mouse_etc();
_add_exit_func(remove_mouse, "remove_mouse");
if (mouse_driver->timer_poll)
install_int(mouse_move, 10);
return num_buttons;
}
