/* al_init will call this. */ ALLEGRO_SYSTEM *iphone_initialize(int flags) { (void)flags; iphone = al_calloc(1, sizeof *iphone); ALLEGRO_SYSTEM *sys = &iphone->system; iphone->mutex = al_create_mutex(); iphone->cond = al_create_cond(); sys->vt = _al_get_iphone_system_interface(); _al_vector_init(&sys->displays, sizeof (ALLEGRO_DISPLAY_IPHONE *)); _al_unix_init_time(); _al_iphone_init_path(); return sys; }
/* [user thread] */ bool _al_gtk_init_args(void *ptr, size_t size) { ARGS_BASE *args = (ARGS_BASE *)ptr; memset(args, 0, size); args->mutex = al_create_mutex(); if (!args->mutex) { return false; } args->cond = al_create_cond(); if (!args->cond) { al_destroy_mutex(args->mutex); return false; } args->done = false; args->response = true; return args; }
/* initialises the input emulation */ void init_input() { ALLEGRO_JOYSTICK *joy; keybuf_len = 0; keybuf_mutex = al_create_mutex(); input_queue = al_create_event_queue(); al_register_event_source(input_queue, al_get_keyboard_event_source()); al_register_event_source(input_queue, al_get_display_event_source( al_get_current_display())); if (al_get_num_joysticks() > 0) { joy = al_get_joystick(0); if (joy) al_register_event_source(input_queue, al_get_joystick_event_source(joy)); } }
static bool t3f_set_music_state(int state) { /* create the mutex if necessary */ if(!t3f_music_state_mutex) { t3f_music_state_mutex = al_create_mutex(); if(!t3f_music_state_mutex) { return false; } } al_lock_mutex(t3f_music_state_mutex); t3f_music_state = state; al_unlock_mutex(t3f_music_state_mutex); return true; }
/* Function: al_create_voice */ ALLEGRO_VOICE *al_create_voice(unsigned int freq, ALLEGRO_AUDIO_DEPTH depth, ALLEGRO_CHANNEL_CONF chan_conf) { ALLEGRO_VOICE *voice = NULL; if (!freq) { _al_set_error(ALLEGRO_INVALID_PARAM, "Invalid Voice Frequency"); return NULL; } voice = al_calloc(1, sizeof(*voice)); if (!voice) { return NULL; } voice->depth = depth; voice->chan_conf = chan_conf; voice->frequency = freq; voice->mutex = al_create_mutex(); voice->cond = al_create_cond(); /* XXX why is this needed? there should only be one active driver */ voice->driver = _al_kcm_driver; ASSERT(_al_kcm_driver); if (_al_kcm_driver->allocate_voice(voice) != 0) { al_destroy_mutex(voice->mutex); al_destroy_cond(voice->cond); al_free(voice); return NULL; } _al_kcm_register_destructor("voice", voice, (void (*)(void *)) al_destroy_voice); return voice; }
int main(void) { ALLEGRO_THREAD *thread[NUM_THREADS]; ALLEGRO_DISPLAY *display; ALLEGRO_TIMER *timer; ALLEGRO_EVENT_QUEUE *queue; ALLEGRO_EVENT event; bool need_draw; int i; for (i = 0; i < 256; i++) { sin_lut[i] = 128 + (int) (127.0 * sin(i / 8.0)); } if (!al_init()) { abort_example("Could not init Allegro.\n"); return 1; } al_install_keyboard(); al_install_mouse(); display = al_create_display(W * IMAGES_PER_ROW, H * NUM_THREADS / IMAGES_PER_ROW); if (!display) { abort_example("Error creating display\n"); return 1; } timer = al_install_timer(1.0/3); if (!timer) { abort_example("Error creating timer\n"); return 1; } queue = al_create_event_queue(); if (!queue) { abort_example("Error creating event queue\n"); return 1; } al_register_event_source(queue, al_get_display_event_source(display)); al_register_event_source(queue, al_get_keyboard_event_source()); al_register_event_source(queue, al_get_mouse_event_source()); al_register_event_source(queue, al_get_timer_event_source(timer)); /* Note: * Right now, A5 video displays can only be accessed from the thread which * created them (at lesat for OpenGL). To lift this restriction, we could * keep track of the current OpenGL context for each thread and make all * functions accessing the display check for it.. not sure it's worth the * additional complexity though. */ al_set_new_bitmap_format(ALLEGRO_PIXEL_FORMAT_RGB_888); al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP); for (i = 0; i < NUM_THREADS; i++) { thread_info[i].bitmap = al_create_bitmap(W, H); if (!thread_info[i].bitmap) { goto Error; } thread_info[i].mutex = al_create_mutex(); if (!thread_info[i].mutex) { goto Error; } thread_info[i].cond = al_create_cond(); if (!thread_info[i].cond) { goto Error; } thread_info[i].is_paused = false; thread_info[i].random_seed = i; thread[i] = al_create_thread(thread_func, &thread_info[i]); if (!thread[i]) { goto Error; } } set_target(0, -0.56062033041600878303, -0.56064322926933807256); set_target(1, -0.57798076669230014080, -0.63449861991138123418); set_target(2, 0.36676836392830602929, -0.59081385302214906030); set_target(3, -1.48319283039401317303, -0.00000000200514696273); set_target(4, -0.74052910500707636032, 0.18340899525730713915); set_target(5, 0.25437906525768350097, -0.00046678223345789554); set_target(6, -0.56062033041600878303, 0.56064322926933807256); set_target(7, -0.57798076669230014080, 0.63449861991138123418); set_target(8, 0.36676836392830602929, 0.59081385302214906030); for (i = 0; i < NUM_THREADS; i++) { al_start_thread(thread[i]); } al_start_timer(timer); need_draw = true; while (true) { if (need_draw && al_event_queue_is_empty(queue)) { show_images(); need_draw = false; } al_wait_for_event(queue, &event); if (event.type == ALLEGRO_EVENT_TIMER) { need_draw = true; } else if (event.type == ALLEGRO_EVENT_MOUSE_BUTTON_DOWN) { int n = (event.mouse.y / H) * IMAGES_PER_ROW + (event.mouse.x / W); if (n < NUM_THREADS) { double x = event.mouse.x - (event.mouse.x / W) * W; double y = event.mouse.y - (event.mouse.y / H) * H; /* Center to the mouse click position. */ if (thread_info[n].is_paused) { thread_info[n].target_x = x / W - 0.5; thread_info[n].target_y = y / H - 0.5; } toggle_pausedness(n); } } else if (event.type == ALLEGRO_EVENT_DISPLAY_EXPOSE) { need_draw = true; } else if (event.type == ALLEGRO_EVENT_DISPLAY_CLOSE) { break; } else if (event.type == ALLEGRO_EVENT_KEY_DOWN) { if (event.keyboard.keycode == ALLEGRO_KEY_ESCAPE) { break; } need_draw = true; } } for (i = 0; i < NUM_THREADS; i++) { /* Set the flag to stop the thread. The thread might be waiting on a * condition variable, so signal the condition to force it to wake up. */ al_set_thread_should_stop(thread[i]); al_lock_mutex(thread_info[i].mutex); al_broadcast_cond(thread_info[i].cond); al_unlock_mutex(thread_info[i].mutex); /* al_destroy_thread() implicitly joins the thread, so this call is not * strictly necessary. */ al_join_thread(thread[i], NULL); al_destroy_thread(thread[i]); } al_destroy_event_queue(queue); al_uninstall_timer(timer); al_destroy_display(display); return 0; Error: return 1; }
static void packet_queue_init(PacketQueue * q) { memset(q, 0, sizeof(PacketQueue)); q->mutex = al_create_mutex(); q->cond = al_create_cond(); }
static bool open_video(ALLEGRO_VIDEO *video) { VideoState *is = av_mallocz(sizeof *is); int i; AVRational fps; is->video = video; init(); video->data = is; strncpy(is->filename, al_path_cstr(video->filename, '/'), sizeof(is->filename)); is->av_sync_type = DEFAULT_AV_SYNC_TYPE; // Open video file #ifdef FFMPEG_0_8 if (avformat_open_input(&is->format_context, is->filename, NULL, NULL) != 0) { #else if (av_open_input_file(&is->format_context, is->filename, NULL, 0, NULL) != 0) { #endif av_free(is); return false; } if (av_find_stream_info(is->format_context) < 0) { av_free(is); return false; } is->video_index = -1; is->audio_index = -1; for (i = 0; i < (int)is->format_context->nb_streams; i++) { if (is->format_context->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO && is->video_index < 0) { is->video_index = i; } if (is->format_context->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO && is->audio_index < 0) { is->audio_index = i; } } fps = is->format_context->streams[is->video_index]->r_frame_rate; video->fps = (double)fps.num / fps.den; video->audio_rate = is->format_context->streams[is->audio_index]-> codec->sample_rate; video->width = is->format_context->streams[is->video_index]->codec->width; video->height = is->format_context->streams[is->video_index]->codec->height; is->pictq_mutex = al_create_mutex(); is->pictq_cond = al_create_cond(); is->timer_mutex = al_create_mutex(); is->timer_cond = al_create_cond(); return true; } static bool close_video(ALLEGRO_VIDEO *video) { VideoState *is = video->data; is->quit = true; if (is->timer_thread) { al_lock_mutex(is->timer_mutex); al_signal_cond(is->timer_cond); al_unlock_mutex(is->timer_mutex); al_join_thread(is->timer_thread, NULL); } if (is->parse_thread) { al_join_thread(is->parse_thread, NULL); } al_destroy_mutex(is->timer_mutex); al_destroy_cond(is->timer_cond); av_free(is); return true; }
void main_loop(ALLEGRO_EVENT_QUEUE *event_queue) { int color = 0, c2 = 0, c3 = 0; bool stlacene_tlacitka[ALLEGRO_KEY_MAX]; memset(stlacene_tlacitka, 0, sizeof(stlacene_tlacitka)); struct Player *player; player = player_new(); struct Objekt * obj = malloc(sizeof(struct Objekt)); list_add(&scena, obj); obj->objekt = player; obj->draw = player_draw; obj->destroy = player_destroy; obj->copy = player_copy; mutex = al_create_mutex(); ALLEGRO_THREAD *thread = al_create_thread(kresliace_vlakno, event_queue); al_start_thread(thread); for (;;) { ALLEGRO_EVENT event; al_wait_for_event(event_queue, &event); if (event.type == ALLEGRO_EVENT_DISPLAY_CLOSE) { break; } if (event.type == ALLEGRO_EVENT_TIMER) { al_lock_mutex(mutex); if (stlacene_tlacitka[ALLEGRO_KEY_LEFT]) { player->x = player->x - 10; if (player->x < 0) player->x = 0; } if (stlacene_tlacitka[ALLEGRO_KEY_RIGHT]) { player->x = player->x + 10; if (player->x > SCREEN_W - 64) player->x = SCREEN_W - 64; } al_unlock_mutex(mutex); } if (event.type == ALLEGRO_EVENT_KEY_DOWN ||event.type == ALLEGRO_EVENT_KEY_UP) { ALLEGRO_KEYBOARD_STATE stav_klavesnice; al_get_keyboard_state(&stav_klavesnice); if (al_key_down(&stav_klavesnice, ALLEGRO_KEY_ESCAPE)) { break; } if (al_key_down(&stav_klavesnice, ALLEGRO_KEY_LEFT)) { stlacene_tlacitka[ALLEGRO_KEY_LEFT] = true; } else { stlacene_tlacitka[ALLEGRO_KEY_LEFT] = false; } if (al_key_down(&stav_klavesnice, ALLEGRO_KEY_RIGHT)) { stlacene_tlacitka[ALLEGRO_KEY_RIGHT] = true; } else { stlacene_tlacitka[ALLEGRO_KEY_RIGHT] = false; } if (al_key_down(&stav_klavesnice, ALLEGRO_KEY_UP)) { stlacene_tlacitka[ALLEGRO_KEY_UP] = true; } else { stlacene_tlacitka[ALLEGRO_KEY_UP] = false; } if (al_key_down(&stav_klavesnice, ALLEGRO_KEY_DOWN)) { stlacene_tlacitka[ALLEGRO_KEY_DOWN] = true; } else { stlacene_tlacitka[ALLEGRO_KEY_DOWN] = false; } } } al_destroy_thread(thread); }
/* return the player so you can use more advanced features if you want you can safely ignore the return value if all you want is to play a mod */ DUMBA5_PLAYER * dumba5_create_player(DUH * dp, int pattern, bool loop, int bufsize, int frequency, bool stereo) { DUMBA5_PLAYER * player; ALLEGRO_CHANNEL_CONF c_conf; int n_channels = 2; /* This restriction is imposed by Allegro. */ ASSERT(n_channels > 0); ASSERT(n_channels <= 2); if(!dp) { return NULL; } player = (DUMBA5_PLAYER *) malloc(sizeof(DUMBA5_PLAYER)); if(!player) { return NULL; } player->flags = 0; player->bufsize = bufsize; player->freq = frequency; player->channels = n_channels; if(n_channels == 1) { c_conf = ALLEGRO_CHANNEL_CONF_1; } else { c_conf = ALLEGRO_CHANNEL_CONF_2; } player->stream = al_create_audio_stream(4, bufsize, frequency, ALLEGRO_AUDIO_DEPTH_INT16, c_conf); if(!player->stream) { free(player); return NULL; } al_attach_audio_stream_to_mixer(player->stream, al_get_default_mixer()); player->sigrenderer = dumb_it_start_at_order(dp, n_channels, pattern); if(!player->sigrenderer) { al_destroy_audio_stream(player->stream); free(player); return NULL; } player->mutex = al_create_mutex(); if(!player->mutex) { return NULL; } player->thread = al_create_thread(dumba5_update_thread, player); if(!player->thread) { return NULL; } player->volume = 1.0; player->silentcount = 0; player->duh = dp; return player; }
void _al_glsl_init_shaders(void) { _al_vector_init(&shaders, sizeof(ALLEGRO_SHADER *)); shaders_mutex = al_create_mutex(); }
NINE_PATCH_BITMAP *create_nine_patch_bitmap(ALLEGRO_BITMAP *bmp, bool owns_bitmap) { int i; NINE_PATCH_BITMAP *p9; ALLEGRO_COLOR c; p9 = al_malloc(sizeof(*p9)); p9->bmp = bmp; p9->destroy_bmp = owns_bitmap; p9->h.m = NULL; p9->v.m = NULL; p9->cached_dw = 0; p9->cached_dh = 0; p9->mutex = al_create_mutex(); p9->width = al_get_bitmap_width(bmp) - 2; p9->height = al_get_bitmap_height(bmp) - 2; al_lock_bitmap(bmp, ALLEGRO_PIXEL_FORMAT_ANY, ALLEGRO_LOCK_READONLY); if (p9->width <= 0 || p9->height <= 0) goto bad_bitmap; /* make sure all four corners are transparent */ #define _check_pixel(x, y) \ c = al_get_pixel(bmp, x, y); \ if (c.a != 0 && c.r + c.g + c.b + c.a != 4) goto bad_bitmap; _check_pixel(0,0); _check_pixel(al_get_bitmap_width(bmp) - 1, 0); _check_pixel(0, al_get_bitmap_height(bmp) - 1); _check_pixel(al_get_bitmap_width(bmp) - 1, al_get_bitmap_height(bmp) - 1); #undef _check_pixel p9->padding.top = p9->padding.right = p9->padding.bottom = p9->padding.left = -1; i = 1; while (i < al_get_bitmap_width(bmp)) { c = al_get_pixel(bmp, i, al_get_bitmap_height(bmp) - 1); if (c.r + c.g + c.b == 0 && c.a == 1) { if (p9->padding.left == -1) p9->padding.left = i - 1; else if (p9->padding.right != -1) goto bad_bitmap; } else if (c.a == 0 || c.r + c.g + c.b + c.a == 4) { if (p9->padding.left != -1 && p9->padding.right == -1) p9->padding.right = al_get_bitmap_width(bmp) - i - 1; } ++i; } i = 1; while (i < al_get_bitmap_height(bmp)) { c = al_get_pixel(bmp, al_get_bitmap_width(bmp) - 1, i); if (c.r + c.g + c.b == 0 && c.a == 1) { if (p9->padding.top == -1) p9->padding.top = i - 1; else if (p9->padding.bottom != -1) goto bad_bitmap; } else if (c.a == 0 || c.r + c.g + c.b + c.a == 4) { if (p9->padding.top != -1 && p9->padding.bottom == -1) p9->padding.bottom = al_get_bitmap_height(bmp) - i - 1; } ++i; } if (!init_nine_patch_side(&p9->h, bmp, 0) || !init_nine_patch_side(&p9->v, bmp, 1)) { bad_bitmap: al_destroy_mutex(p9->mutex); if (p9->h.m) al_free(p9->h.m); if (p9->v.m) al_free(p9->v.m); al_free(p9); p9 = NULL; } al_unlock_bitmap(bmp); return p9; }
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; }
//initializes the resource manager; invoked from algui_init int _algui_init_resource_manager() { _mutex = al_create_mutex(); if (!_mutex) return 0; return 1; }
int main(int argc, char **argv) { ALLEGRO_DISPLAY *display; ALLEGRO_TIMER *timer; ALLEGRO_EVENT_QUEUE *queue; bool redraw = true; ALLEGRO_FONT *font; ALLEGRO_BITMAP *spin, *spin2; int current_bitmap = 0; int loaded_bitmap = 0; ALLEGRO_THREAD *thread; (void)argc; (void)argv; if (!al_init()) { abort_example("Could not init Allegro.\n"); } al_init_image_addon(); al_init_font_addon(); al_init_primitives_addon(); init_platform_specific(); open_log(); al_install_mouse(); al_install_keyboard(); spin = al_load_bitmap("data/cursor.tga"); log_printf("default bitmap without display: %p\n", spin); al_set_new_bitmap_flags(ALLEGRO_VIDEO_BITMAP); spin2 = al_load_bitmap("data/cursor.tga"); log_printf("video bitmap without display: %p\n", spin2); log_printf("%p before create_display: ", spin); print_bitmap_flags(spin); log_printf("\n"); display = al_create_display(64, 64); if (!display) { abort_example("Error creating display\n"); } spin2 = al_load_bitmap("data/cursor.tga"); log_printf("video bitmap with display: %p\n", spin2); log_printf("%p after create_display: ", spin); print_bitmap_flags(spin); log_printf("\n"); log_printf("%p after create_display: ", spin2); print_bitmap_flags(spin2); log_printf("\n"); al_destroy_display(display); log_printf("%p after destroy_display: ", spin); print_bitmap_flags(spin); log_printf("\n"); log_printf("%p after destroy_display: ", spin2); print_bitmap_flags(spin2); log_printf("\n"); display = al_create_display(640, 480); log_printf("%p after create_display: ", spin); print_bitmap_flags(spin); log_printf("\n"); log_printf("%p after create_display: ", spin2); print_bitmap_flags(spin2); log_printf("\n"); font = al_load_font("data/fixed_font.tga", 0, 0); mutex = al_create_mutex(); thread = al_create_thread(loading_thread, NULL); al_start_thread(thread); timer = al_create_timer(1.0 / 30); queue = al_create_event_queue(); al_register_event_source(queue, al_get_keyboard_event_source()); al_register_event_source(queue, al_get_display_event_source(display)); al_register_event_source(queue, al_get_timer_event_source(timer)); al_start_timer(timer); while (1) { ALLEGRO_EVENT event; al_wait_for_event(queue, &event); if (event.type == ALLEGRO_EVENT_DISPLAY_CLOSE) break; if (event.type == ALLEGRO_EVENT_KEY_DOWN) { if (event.keyboard.keycode == ALLEGRO_KEY_ESCAPE) break; } if (event.type == ALLEGRO_EVENT_TIMER) redraw = true; if (redraw && al_is_event_queue_empty(queue)) { float x = 20, y = 320; int i; ALLEGRO_COLOR color = al_map_rgb_f(0, 0, 0); float t = al_current_time(); redraw = false; al_clear_to_color(al_map_rgb_f(0.5, 0.6, 1)); al_draw_textf(font, color, x + 40, y, 0, "Loading %d%%", 100 * load_count / load_total); al_lock_mutex(mutex); if (loaded_bitmap < load_count) { /* This will convert any video bitmaps without a display * (all the bitmaps being loaded in the loading_thread) to * video bitmaps we can use in the main thread. */ al_convert_bitmap(bitmaps[loaded_bitmap]); loaded_bitmap++; } al_unlock_mutex(mutex); if (current_bitmap < loaded_bitmap) { int bw; al_draw_bitmap(bitmaps[current_bitmap], 0, 0, 0); if (current_bitmap + 1 < loaded_bitmap) current_bitmap++; for (i = 0; i <= current_bitmap; i++) { bw = al_get_bitmap_width(bitmaps[i]); al_draw_scaled_rotated_bitmap(bitmaps[i], 0, 0, (i % 20) * 640 / 20, 360 + (i / 20) * 24, 32.0 / bw, 32.0 / bw, 0, 0); } } if (loaded_bitmap < load_total) { al_draw_scaled_rotated_bitmap(spin, 16, 16, x, y, 1.0, 1.0, t * ALLEGRO_PI * 2, 0); } al_flip_display(); } } al_join_thread(thread, NULL); al_destroy_mutex(mutex); al_destroy_font(font); al_destroy_display(display); close_log(true); return 0; }
Framework::Framework() { #ifdef WRITE_LOG printf( "Framework: Startup\n" ); #endif // Init Allegro if( !al_init() ) { return; } al_init_font_addon(); if( !al_install_keyboard() || !al_install_mouse() || !al_init_primitives_addon() || !al_init_ttf_addon() || !al_init_image_addon() ) { return; } if( al_install_joystick() ) { al_reconfigure_joysticks(); } audioInitialised = false; InitialiseAudioSystem(); std::string selectedLanguage; quitProgram = false; ProgramStages = new StageStack(); framesToProcess = 0; Settings = new ConfigFile( "settings.cfg" ); eventQueue = al_create_event_queue(); InitialiseDisplay(); al_register_event_source( eventQueue, al_get_keyboard_event_source() ); al_register_event_source( eventQueue, al_get_mouse_event_source() ); fpsTimer = al_create_timer( 1.0 / (float)FRAMES_PER_SECOND ); al_register_event_source( eventQueue, al_get_timer_event_source( fpsTimer ) ); al_start_timer( fpsTimer ); al_hide_mouse_cursor( displaySurface ); imageMgr = new ImageManager( this ); fontMgr = new FontManager( this ); audioMgr = new AudioManager( this ); int maxDownloads = 4; if( Settings->KeyExists( "Downloads.MaxConcurrentDownloads" ) ) { Settings->GetIntegerValue( "Downloads.MaxConcurrentDownloads", &maxDownloads ); } downloadMgr = new DownloadManager( this, maxDownloads ); networkMgr = new NetworkManager( this ); languageMgr = new LanguageManager(); if( Settings->KeyExists( "Application.Language" ) ) { Settings->GetStringValue( "Application.Language", &selectedLanguage ); languageMgr->SetActiveLanguage( selectedLanguage ); } NativePlatform = new Platform(); SystemFramework = this; extraEventsMutex = al_create_mutex(); }
DATA() : mutex(al_create_mutex()), cond(al_create_cond()), posiX (0), posiY (0), modi_X(false), ready (false) {}