int main(void)
{
ALLEGRO_DISPLAY *display;
ALLEGRO_BITMAP *icons[NUM_ICONS];
ALLEGRO_EVENT_QUEUE *queue;
int u, v;
if (!al_init()) {
abort_example("Could not init Allegro.\n");
}
al_install_keyboard();
al_init_image_addon();
display = al_create_display(320, 200);
if (!display) {
abort_example("Error creating display\n");
}
al_clear_to_color(al_map_rgb_f(0, 0, 0));
al_flip_display();
/* First icon 16x16: Read from file. */
icons[0] = al_load_bitmap("data/cursor.tga");
if (!icons[0]) {
abort_example("icons.tga not found\n");
}
/* Second icon 32x32: Create it. */
al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP);
icons[1] = al_create_bitmap(32, 32);
al_set_target_bitmap(icons[1]);
for (v = 0; v < 32; v++) {
for (u = 0; u < 32; u++) {
al_put_pixel(u, v, al_map_rgb_f(u / 31.0, v / 31.0, 1));
}
}
al_set_target_backbuffer(display);
al_set_display_icons(display, NUM_ICONS, icons);
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));
for (;;) {
ALLEGRO_EVENT event;
al_wait_for_event(queue, &event);
if (event.type == ALLEGRO_EVENT_KEY_DOWN &&
event.keyboard.keycode == ALLEGRO_KEY_ESCAPE) {
break;
}
if (event.type == ALLEGRO_EVENT_DISPLAY_CLOSE) {
break;
}
}
al_uninstall_system();
return 0;
}
int main(void)
{
int i;
if (!al_init()) {
abort_example("Could not init Allegro.\n");
}
al_install_keyboard();
open_log();
display = al_create_display(640, 100);
if (!display) {
abort_example("Could not create display.\n");
}
if (!al_install_audio()) {
abort_example("Could not init sound.\n");
}
al_reserve_samples(N);
al_set_mixer_postprocess_callback(al_get_default_mixer(), update_waveform, NULL);
mainloop();
close_log(false);
for (i = 0; i < N; i++) {
al_destroy_audio_stream(stream[i]);
}
al_uninstall_audio();
return 0;
}
int main(void)
{
ALLEGRO_DISPLAY *dpy;
ALLEGRO_EVENT_QUEUE *queue;
if (!al_init()) {
abort_example("Could not init Allegro.\n");
return 1;
}
al_install_keyboard();
dpy = al_create_display(640, 480);
if (!dpy) {
abort_example("Unable to set any graphic mode\n");
return 1;
}
queue = al_create_event_queue();
al_register_event_source(queue, al_get_keyboard_event_source());
test_relative_timeout(queue);
test_absolute_timeout(queue);
return 0;
}
int main(void)
{
if (!al_init()) {
abort_example("Could not init Allegro.\n");
}
open_log_monospace();
display = al_create_display(WIDTH, HEIGHT);
if (!display) {
abort_example("al_create_display failed\n");
}
al_clear_to_color(al_map_rgb_f(0, 0, 0));
al_flip_display();
if (!al_install_keyboard()) {
abort_example("al_install_keyboard failed\n");
}
event_queue = al_create_event_queue();
if (!event_queue) {
abort_example("al_create_event_queue failed\n");
}
al_register_event_source(event_queue, al_get_keyboard_event_source());
al_register_event_source(event_queue, al_get_display_event_source(display));
main_loop();
close_log(false);
return 0;
}
int main(void)
{
ALLEGRO_DISPLAY *display;
ALLEGRO_EVENT_QUEUE *queue;
ALLEGRO_EVENT event;
int frames = 0;
double start;
if (!al_init()) {
abort_example("Could not init Allegro.\n");
return 1;
}
al_install_keyboard();
al_set_new_display_flags(ALLEGRO_OPENGL);
display = al_create_display(640, 480);
if (!display) {
abort_example("Could not create display.\n");
return 1;
}
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));
start = al_get_time();
while (true) {
/* Check for ESC key or close button event and quit in either case. */
if (!al_is_event_queue_empty(queue)) {
while (al_get_next_event(queue, &event)) {
switch (event.type) {
case ALLEGRO_EVENT_DISPLAY_CLOSE:
goto done;
case ALLEGRO_EVENT_KEY_DOWN:
if (event.keyboard.keycode == ALLEGRO_KEY_ESCAPE)
goto done;
break;
}
}
}
draw_opengl();
al_flip_display();
frames++;
}
done:
printf("%.1f FPS\n", frames / (al_get_time() - start));
al_destroy_event_queue(queue);
return 0;
}
int main(int argc, char **argv)
{
ALLEGRO_DISPLAY *display;
ALLEGRO_BITMAP *cursor;
ALLEGRO_MOUSE_STATE msestate;
ALLEGRO_KEYBOARD_STATE kbdstate;
int i;
(void)argc;
(void)argv;
if (!al_init()) {
abort_example("Could not init Allegro.\n");
}
al_init_primitives_addon();
al_install_mouse();
al_install_keyboard();
al_init_image_addon();
init_platform_specific();
display = al_create_display(640, 480);
if (!display) {
abort_example("Error creating display\n");
}
al_hide_mouse_cursor(display);
cursor = al_load_bitmap("data/cursor.tga");
if (!cursor) {
abort_example("Error loading cursor.tga\n");
}
do {
al_get_mouse_state(&msestate);
al_get_keyboard_state(&kbdstate);
al_clear_to_color(al_map_rgb(0xff, 0xff, 0xc0));
for (i = 1; i <= NUM_BUTTONS; i++) {
draw_mouse_button(i, al_mouse_button_down(&msestate, i));
}
al_draw_bitmap(cursor, msestate.x, msestate.y, 0);
al_flip_display();
al_rest(0.005);
} while (!al_key_down(&kbdstate, ALLEGRO_KEY_ESCAPE));
return 0;
}
int main(int argc, const char *argv[])
{
enum Mode mode = ALL;
int i;
if (argc > 1) {
i = strtol(argv[1], NULL, 10);
switch (i) {
case 0:
mode = PLAIN_BLIT;
break;
case 1:
mode = SCALED_BLIT;
break;
case 2:
mode = ROTATE_BLIT;
break;
}
}
if (!al_init()) {
abort_example("Could not init Allegro\n");
}
open_log();
al_init_image_addon();
al_init_primitives_addon();
display = al_create_display(640, 480);
if (!display) {
abort_example("Error creating display\n");
}
if (mode == ALL) {
for (mode = PLAIN_BLIT; mode <= ROTATE_BLIT; mode++) {
do_test(mode);
}
}
else {
do_test(mode);
}
al_destroy_display(display);
close_log(true);
return 0;
}
static ALLEGRO_BITMAP *load_bitmap(char const *filename)
{
ALLEGRO_BITMAP *bitmap = al_load_bitmap(filename);
if (!bitmap)
abort_example("%s not found or failed to load\n", filename);
return bitmap;
}
int main(int argc, const char *argv[])
{
int i;
if (!al_init()) {
abort_example("Could not init Allegro.\n");
}
open_log_monospace();
if (argc < 2) {
for (i = 1; i < NUM_TESTS; i++) {
log_printf("# t%d\n\n", i);
all_tests[i]();
log_printf("\n");
}
}
else {
i = atoi(argv[1]);
if (i > 0 && i < NUM_TESTS) {
all_tests[i]();
}
}
close_log(true);
if (error) {
exit(EXIT_FAILURE);
}
return 0;
}
int main(int argc, char **argv)
{
int i;
if (!al_init()) {
abort_example("Could not init Allegro.\n");
}
open_log_monospace();
log_printf("%-36s %-6s %8s %8s %8s %8s\n",
"name", "flags", "ctime", "mtime", "atime", "size");
log_printf(
"------------------------------------ "
"------ "
"-------- "
"-------- "
"-------- "
"--------\n");
if (argc == 1) {
ALLEGRO_FS_ENTRY *entry = al_create_fs_entry("data");
print_entry(entry);
al_destroy_fs_entry(entry);
}
for (i = 1; i < argc; i++) {
ALLEGRO_FS_ENTRY *entry = al_create_fs_entry(argv[i]);
print_entry(entry);
al_destroy_fs_entry(entry);
}
close_log(true);
return 0;
}
int main(int argc, char * argv[])
{
ALLEGRO_CONFIG *config;
ALLEGRO_EVENT event;
unsigned buffer_count;
unsigned samples;
const char *s;
initialize();
if (argc < 2) {
log_printf("This example needs to be run from the command line.\nUsage: %s {audio_files}\n", argv[0]);
goto done;
}
buffer_count = 0;
samples = 0;
config = al_load_config_file("ex_stream_seek.cfg");
if (config) {
if ((s = al_get_config_value(config, "", "buffer_count"))) {
buffer_count = atoi(s);
}
if ((s = al_get_config_value(config, "", "samples"))) {
samples = atoi(s);
}
al_destroy_config(config);
}
if (buffer_count == 0) {
buffer_count = 4;
}
if (samples == 0) {
samples = 1024;
}
stream_filename = argv[1];
music_stream = al_load_audio_stream(stream_filename, buffer_count, samples);
if (!music_stream) {
abort_example("Stream error!\n");
}
loop_start = 0.0;
loop_end = al_get_audio_stream_length_secs(music_stream);
al_set_audio_stream_loop_secs(music_stream, loop_start, loop_end);
al_set_audio_stream_playmode(music_stream, ALLEGRO_PLAYMODE_LOOP);
al_attach_audio_stream_to_mixer(music_stream, al_get_default_mixer());
al_start_timer(timer);
while (!exiting) {
al_wait_for_event(queue, &event);
event_handler(&event);
}
done:
myexit();
al_destroy_display(display);
close_log(true);
return 0;
}
int main(int argc, char *argv[])
{
ALLEGRO_DISPLAY *display;
ALLEGRO_FONT *font;
(void)argc;
(void)argv;
if (!al_init()) {
abort_example("Could not init Allegro.\n");
return 1;
}
al_init_primitives_addon();
al_init_image_addon();
al_init_font_addon();
al_install_keyboard();
al_install_mouse();
al_set_new_display_flags(ALLEGRO_GENERATE_EXPOSE_EVENTS);
display = al_create_display(640, 480);
if (!display) {
abort_example("Error creating display\n");
return 1;
}
//printf("Display format = %d\n", al_get_display_format());
font = al_load_font("data/fixed_font.tga", 0, 0);
if (!font) {
abort_example("Failed to load data/fixed_font.tga\n");
return 1;
}
/* Don't remove these braces. */
{
Theme theme(font);
Prog prog(theme, display);
prog.run();
}
al_destroy_font(font);
return 0;
}
static void initialize(void)
{
if (!al_init()) {
abort_example("Could not init Allegro.\n");
}
open_log();
al_init_primitives_addon();
al_init_image_addon();
al_init_font_addon();
if (!al_install_keyboard()) {
abort_example("Could not init keyboard!\n");
}
if (!al_install_mouse()) {
abort_example("Could not init mouse!\n");
}
al_init_acodec_addon();
if (!al_install_audio()) {
abort_example("Could not init sound!\n");
}
if (!al_reserve_samples(16)) {
abort_example("Could not set up voice and mixer.\n");
}
init_platform_specific();
display = al_create_display(640, 228);
if (!display) {
abort_example("Could not create display!\n");
}
basic_font = al_load_font("data/font.tga", 0, 0);
if (!basic_font) {
abort_example("Could not load font!\n");
}
timer = al_create_timer(1.000 / 30);
if (!timer) {
abort_example("Could not init timer!\n");
}
queue = al_create_event_queue();
if (!queue) {
abort_example("Could not create event queue!\n");
}
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_display_event_source(display));
al_register_event_source(queue, al_get_timer_event_source(timer));
}
int main(int argc, char **argv)
{
ALLEGRO_EVENT_SOURCE fake_src;
ALLEGRO_EVENT_QUEUE *queue;
ALLEGRO_EVENT fake_keydown_event, fake_joystick_event;
ALLEGRO_EVENT event;
(void)argc;
(void)argv;
if (!al_init()) {
abort_example("Could not init Allegro.\n");
}
open_log();
/* register our 'fake' event source with the queue */
al_init_user_event_source(&fake_src);
queue = al_create_event_queue();
al_register_event_source(queue, &fake_src);
/* fake a joystick event */
fake_joystick_event.any.type = ALLEGRO_EVENT_JOYSTICK_AXIS;
fake_joystick_event.joystick.stick = 1;
fake_joystick_event.joystick.axis = 0;
fake_joystick_event.joystick.pos = 0.5;
al_emit_user_event(&fake_src, &fake_joystick_event, NULL);
/* fake a keyboard event */
fake_keydown_event.any.type = ALLEGRO_EVENT_KEY_DOWN;
fake_keydown_event.keyboard.keycode = ALLEGRO_KEY_ENTER;
al_emit_user_event(&fake_src, &fake_keydown_event, NULL);
/* poll for the events we injected */
while (!al_is_event_queue_empty(queue)) {
al_wait_for_event(queue, &event);
switch (event.type) {
case ALLEGRO_EVENT_KEY_DOWN:
ALLEGRO_ASSERT(event.user.source == &fake_src);
log_printf("Got keydown: %d\n", event.keyboard.keycode);
break;
case ALLEGRO_EVENT_JOYSTICK_AXIS:
ALLEGRO_ASSERT(event.user.source == &fake_src);
log_printf("Got joystick axis: stick=%d axis=%d pos=%f\n",
event.joystick.stick, event.joystick.axis, event.joystick.pos);
break;
}
}
al_destroy_user_event_source(&fake_src);
al_destroy_event_queue(queue);
log_printf("Done.\n");
close_log(true);
return 0;
}
int main(void)
{
ALLEGRO_DISPLAY *display;
ALLEGRO_EVENT_QUEUE *events;
ALLEGRO_EVENT event;
double last_resize;
int rs = 100;
/* Initialize Allegro and create an event queue. */
if (!al_init()) {
abort_example("Could not init Allegro.\n");
return 1;
}
events = al_create_event_queue();
/* Setup a display driver and register events from it. */
al_set_new_display_flags(ALLEGRO_RESIZABLE);
display = al_create_display(rs, rs);
al_register_event_source(events, al_get_display_event_source(display));
/* Setup a keyboard driver and regsiter events from it. */
al_install_keyboard();
al_register_event_source(events, al_get_keyboard_event_source());
/* Display a pulsating window until a key or the closebutton is pressed. */
redraw();
last_resize = 0;
while (true) {
if (al_get_next_event(events, &event)) {
if (event.type == ALLEGRO_EVENT_DISPLAY_RESIZE) {
ALLEGRO_DISPLAY_EVENT *de = &event.display;
al_acknowledge_resize(de->source);
redraw();
}
if (event.type == ALLEGRO_EVENT_DISPLAY_CLOSE) {
break;
}
if (event.type == ALLEGRO_EVENT_KEY_DOWN) {
break;
}
}
if (al_current_time() - last_resize > 0.1) {
int s;
last_resize = al_current_time();
rs += 10;
if (rs == 300)
rs = 100;
s = rs;
if (s > 200)
s = 400 - s;
al_resize_display(s, s);
}
}
return 0;
}
int main(int argc, char **argv)
{
ALLEGRO_DISPLAY *display;
ALLEGRO_BITMAP *picture;
if (!al_init()) {
abort_example("Could not init Allegro.\n");
return 1;
}
al_init_primitives_addon();
al_install_keyboard();
al_init_image_addon();
open_log_monospace();
if (argc == 2) {
al_set_new_display_adapter(atoi(argv[1]));
}
al_set_new_display_flags(ALLEGRO_FULLSCREEN |
ALLEGRO_GENERATE_EXPOSE_EVENTS);
display = al_create_display(res[cur_res].w, res[cur_res].h);
if (!display) {
abort_example("Error creating display\n");
return 1;
}
picture = al_load_bitmap("data/mysha.pcx");
if (!picture) {
abort_example("mysha.pcx not found\n");
return 1;
}
main_loop(display, picture);
al_destroy_bitmap(picture);
/* Destroying the fullscreen display restores the original screen
* resolution. Shutting down Allegro would automatically destroy the
* display, too.
*/
al_destroy_display(display);
return 0;
}
int main(void)
{
ALLEGRO_COLOR black;
ALLEGRO_COLOR red;
ALLEGRO_KEYBOARD_STATE kbdstate;
if (!al_init()) {
abort_example("Error initialising Allegro.\n");
}
if (!al_install_keyboard()) {
abort_example("Error installing keyboard.\n");
}
display1 = al_create_display(300, 300);
display2 = al_create_display(300, 300);
if (!display1 || !display2) {
abort_example("Error creating displays.\n");
}
black = al_map_rgb(0, 0, 0);
red = al_map_rgb(255, 0, 0);
while (1) {
al_get_keyboard_state(&kbdstate);
if (al_key_down(&kbdstate, ALLEGRO_KEY_ESCAPE)) {
break;
}
if (kbdstate.display == display1) {
redraw(red, black);
}
else if (kbdstate.display == display2) {
redraw(black, red);
}
else {
redraw(black, black);
}
al_rest(0.1);
}
return 0;
}
int main(int argc, char **argv)
{
(void)argc;
(void)argv;
if (!al_init()) {
abort_example("Could not init Allegro.\n");
}
al_init_primitives_addon();
al_install_keyboard();
al_init_image_addon();
al_init_font_addon();
init_platform_specific();
al_set_new_display_flags(ALLEGRO_FULLSCREEN_WINDOW);
display = al_create_display(640, 480);
if (!display) {
abort_example("Error creating display\n");
}
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));
picture = al_load_bitmap("data/mysha.pcx");
if (!picture) {
abort_example("mysha.pcx not found\n");
}
font = al_load_font("data/fixed_font.tga", 0, 0);
if (!font) {
abort_example("data/fixed_font.tga not found.\n");
}
redraw();
run();
al_destroy_display(display);
al_destroy_event_queue(queue);
return 0;
}
int main(void)
{
ALLEGRO_DISPLAY *display;
ALLEGRO_FONT *accelfont;
ALLEGRO_FONT *memfont;
ALLEGRO_BITMAP *accelbmp;
ALLEGRO_BITMAP *membmp;
if (!al_init()) {
abort_example("Could not init Allegro.\n");
}
al_install_keyboard();
al_init_image_addon();
al_init_font_addon();
display = al_create_display(640, 400);
if (!display) {
abort_example("Error creating display\n");
}
accelfont = al_load_font("data/font.tga", 0, 0);
if (!accelfont) {
abort_example("font.tga not found\n");
}
accelbmp = al_load_bitmap("data/mysha.pcx");
if (!accelbmp) {
abort_example("mysha.pcx not found\n");
}
al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP);
memfont = al_load_font("data/font.tga", 0, 0);
membmp = al_load_bitmap("data/mysha.pcx");
for (;;) {
if (test(membmp, memfont, "Memory bitmap (press SPACE key)"))
break;
if (test(accelbmp, accelfont, "Accelerated bitmap (press SPACE key)"))
break;
}
return 0;
}
int main(void)
{
ALLEGRO_DISPLAY *display;
if (!al_init()) {
abort_example("Could not init Allegro.\n");
return 1;
}
al_init_primitives_addon();
display = al_create_display(640, 480);
if (!display) {
abort_example("al_create_display failed\n");
return 1;
}
al_install_keyboard();
black = al_map_rgb(0, 0, 0);
grey = al_map_rgb(0xe0, 0xe0, 0xe0);
white = al_map_rgb(255, 255, 255);
al_install_joystick();
event_queue = al_create_event_queue();
if (!event_queue) {
abort_example("al_create_event_queue failed\n");
return 1;
}
if (al_get_keyboard_event_source()) {
al_register_event_source(event_queue, al_get_keyboard_event_source());
}
al_register_event_source(event_queue, al_get_display_event_source(display));
al_register_event_source(event_queue, al_get_joystick_event_source());
setup_joystick_values(al_get_joystick(0));
main_loop();
return 0;
}
int main(void)
{
if (!al_init()) {
abort_example("Could not init Allegro.\n");
return 1;
}
al_install_keyboard();
al_init_image_addon();
if (al_get_num_video_adapters() < 2) {
abort_example("You need 2 or more adapters/monitors for this example.\n");
return 1;
}
go();
return 0;
}
int main(void)
{
if (!al_init()) {
abort_example("Could not init Allegro.\n");
return 1;
}
al_init_primitives_addon();
al_install_keyboard();
al_init_image_addon();
al_init_font_addon();
display = al_create_display(640, 480);
if (!display) {
abort_example("Error creating display\n");
return 1;
}
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));
myfont = al_load_font("data/font.tga", 0, 0);
if (!myfont) {
abort_example("font.tga not found\n");
return 1;
}
while (!quit) {
if (al_get_new_bitmap_flags() & ALLEGRO_FORCE_LOCKING)
al_set_new_bitmap_flags(ALLEGRO_VIDEO_BITMAP);
else
al_set_new_bitmap_flags(ALLEGRO_FORCE_LOCKING);
run();
}
al_destroy_event_queue(queue);
return 0;
}
int main(int argc, char **argv)
{
ALLEGRO_DISPLAY *display;
ALLEGRO_TIMER *timer;
(void)argc;
(void)argv;
if (!al_init()) {
abort_example("Could not init Allegro.\n");
}
al_install_keyboard();
al_install_mouse();
al_init_image_addon();
al_init_font_addon();
init_platform_specific();
display = al_create_display(640, 480);
if (!display) {
abort_example("Error creating display\n");
}
init();
timer = al_create_timer(1.0 / ex.FPS);
ex.queue = al_create_event_queue();
al_register_event_source(ex.queue, al_get_keyboard_event_source());
al_register_event_source(ex.queue, al_get_mouse_event_source());
al_register_event_source(ex.queue, al_get_display_event_source(display));
al_register_event_source(ex.queue, al_get_timer_event_source(timer));
al_start_timer(timer);
run();
al_destroy_event_queue(ex.queue);
return 0;
}
int main(int argc, const char *argv[])
{
const char *url;
ALLEGRO_DISPLAY *display;
ALLEGRO_BITMAP *bmp;
if (argc > 1)
url = argv[1];
else
url = "http://liballeg.org/images/logo.png";
if (!al_init()) {
abort_example("Could not init Allegro.\n");
}
open_log();
al_init_image_addon();
al_install_keyboard();
display = al_create_display(640, 480);
if (!display) {
abort_example("Unable to create display.\n");
}
curl_global_init(CURL_GLOBAL_ALL);
al_set_new_file_interface(&curl_file_vtable);
bmp = al_load_bitmap(url);
if (bmp) {
show_image(bmp);
al_destroy_bitmap(bmp);
}
curl_global_cleanup();
close_log(true);
return 0;
}
int main(int argc, const char *argv[])
{
ALLEGRO_THREAD *thread[MAX_THREADS];
Background background[MAX_BACKGROUNDS] = {
{ 1.0, 0.5, 0.5 },
{ 0.5, 1.0, 0.5 },
{ 0.5, 0.5, 1.0 },
{ 1.0, 1.0, 0.5 },
{ 0.5, 1.0, 1.0 },
{ 1.0, 0.7, 0.5 },
{ 0.5, 1.0, 0.7 },
{ 0.7, 0.5, 1.0 },
{ 1.0, 0.7, 0.5 },
{ 0.5, 0.7, 1.0 }
};
int num_threads;
int i;
if (argc > 1) {
num_threads = strtol(argv[1], NULL, 10);
if (num_threads > MAX_THREADS)
num_threads = MAX_THREADS;
else if (num_threads < 1)
num_threads = 1;
}
else {
num_threads = 3;
}
if (!al_init()) {
abort_example("Could not init Allegro.\n");
return 1;
}
al_init_primitives_addon();
al_install_keyboard();
al_install_mouse();
for (i = 0; i < num_threads; i++) {
thread[i] = al_create_thread(thread_func,
&background[i % MAX_BACKGROUNDS]);
}
for (i = 0; i < num_threads; i++) {
al_start_thread(thread[i]);
}
for (i = 0; i < num_threads; i++) {
al_join_thread(thread[i], NULL);
al_destroy_thread(thread[i]);
}
return 0;
}
static void init(void)
{
ex.FPS = 60;
ex.font = al_load_font("data/fixed_font.tga", 0, 0);
if (!ex.font) {
abort_example("data/fixed_font.tga not found\n");
}
ex.background = al_color_name("beige");
ex.text = al_color_name("black");
ex.white = al_color_name("white");
ex.pattern = example_bitmap(100, 100);
}
int main(int argc, char *argv[])
{
ALLEGRO_DISPLAY *display;
ALLEGRO_FONT *font;
(void)argc;
(void)argv;
if (!al_init()) {
abort_example("Could not init Allegro\n");
return 1;
}
al_init_primitives_addon();
al_install_keyboard();
al_install_mouse();
al_init_font_addon();
al_init_ttf_addon();
al_set_new_display_flags(ALLEGRO_GENERATE_EXPOSE_EVENTS);
display = al_create_display(640, 480);
if (!display) {
abort_example("Unable to create display\n");
return 1;
}
font = al_load_font("data/DejaVuSans.ttf", 12, 0);
if (!font) {
abort_example("Failed to load data/DejaVuSans.ttf\n");
return 1;
}
Theme theme(font);
Prog prog(theme, display);
prog.run();
al_destroy_font(font);
return 0;
}
int main(int argc, const char *argv[])
{
ALLEGRO_FILE *master, *slice;
ALLEGRO_PATH *tmp_path;
const char *first_string = "Hello, World!";
const char *second_string = "The quick brown fox jumps over the lazy dog.";
char buffer[BUFFER_SIZE];
(void) argc, (void) argv;
al_init();
master = al_make_temp_file("ex_file_slice_XXXX", &tmp_path);
if (!master) {
abort_example("Unable to create temporary file\n");
}
/* Pack both strings into the master file. */
pack_object(master, first_string, strlen(first_string));
pack_object(master, second_string, strlen(second_string));
/* Seek back to the beginning of the file, as if we had just opened it */
al_fseek(master, 0, ALLEGRO_SEEK_SET);
/* Loop through the main file, opening a slice for each object */
while ((slice = get_next_chunk(master))) {
/* Note: While the slice is open, we must avoid using the master file!
If you were dealing with packed images, this is where you would pass 'slice'
to al_load_bitmap_f(). */
if (al_fsize(slice) < BUFFER_SIZE) {
/* We could have used al_fgets(), but just to show that the file slice
is constrained to the string object, we'll read the entire slice. */
al_fread(slice, buffer, al_fsize(slice));
buffer[al_fsize(slice)] = 0;
printf("Chunk of size %d: '%s'\n", (int) al_fsize(slice), buffer);
}
/* The slice must be closed before the next slice is opened. Closing
the slice will advanced the master file to the end of the slice. */
al_fclose(slice);
}
al_fclose(master);
al_remove_filename(al_path_cstr(tmp_path, '/'));
return 0;
}
/* Initialize the example. */
static void init(void)
{
ex.BUTTONS_X = 40 + 110 * 4;
ex.FPS = 60;
ex.myfont = al_load_font("data/font.tga", 0, 0);
if (!ex.myfont) {
abort_example("data/font.tga not found\n");
}
ex.example = create_example_bitmap();
ex.offscreen = al_create_bitmap(640, 480);
al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP);
ex.memory = al_create_bitmap(640, 480);
}
static void init(void)
{
ex.FPS = 60;
ex.font = al_load_font("data/fixed_font.tga", 0, 0);
if (!ex.font) {
abort_example("data/fixed_font.tga not found.\n");
}
ex.background = al_color_name("beige");
ex.foreground = al_color_name("black");
ex.outline = al_color_name("red");
ex.text = al_color_name("blue");
ex.white = al_color_name("white");
ex.pattern = al_create_bitmap(32, 32);
ex.zoom = al_create_bitmap(32, 32);
draw_pattern(ex.pattern);
}
