allegro4r 0.0.1

data/ext/a4r_API_transparency_and_patterned_drawing.c

@@ -0,0 +1,87 @@
+#include "allegro4r.h"
+
+/*
+ * call-seq:
+ *   drawing_mode(mode, pattern, x_anchor, y_anchor) -> nil
+ *
+ * Sets the graphics drawing mode. This only affects the geometric routines like
+ * putpixel, lines, rectangles, circles, polygons, floodfill, etc, not the text
+ * output, blitting, or sprite drawing functions. The mode should be one of the
+ * following constants:
+ *   DRAW_MODE_SOLID               - the default, solid color drawing
+ *   DRAW_MODE_XOR                 - exclusive-or drawing
+ *   DRAW_MODE_COPY_PATTERN        - multicolored pattern fill
+ *   DRAW_MODE_SOLID_PATTERN       - single color pattern fill
+ *   DRAW_MODE_MASKED_PATTERN      - masked pattern fill
+ *   DRAW_MODE_TRANS               - translucent color blending
+ *
+ * In DRAW_MODE_SOLID, pixels of the bitmap being drawn onto are simply replaced
+ * by those produced by the drawing function.
+ *
+ * In DRAW_MODE_XOR, pixels are written to the bitmap with an exclusive-or
+ * operation rather than a simple copy, so drawing the same shape twice will
+ * erase it. Because it involves reading as well as writing the bitmap memory,
+ * xor drawing is a lot slower than the normal replace mode.
+ *
+ * With the patterned modes, you provide a pattern bitmap which is tiled across
+ * the surface of the shape. Allegro stores a pointer to this bitmap rather than
+ * copying it, so you must not destroy the bitmap while it is still selected as
+ * the pattern. The width and height of the pattern must be powers of two, but
+ * they can be different, eg. a 64x16 pattern is fine, but a 17x3 one is not.
+ * The pattern is tiled in a grid starting at point (x_anchor, y_anchor).
+ * Normally you should just pass zero for these values, which lets you draw
+ * several adjacent shapes and have the patterns meet up exactly along the
+ * shared edges. Zero alignment may look peculiar if you are moving a patterned
+ * shape around the screen, however, because the shape will move but the pattern
+ * alignment will not, so in some situations you may wish to alter the anchor
+ * position.
+ *
+ * When you select DRAW_MODE_COPY_PATTERN, pixels are simply copied from the
+ * pattern bitmap onto the destination bitmap. This allows the use of
+ * multicolored patterns, and means that the color you pass to the drawing
+ * routine is ignored. This is the fastest of the patterned modes.
+ *
+ * In DRAW_MODE_SOLID_PATTERN, each pixel in the pattern bitmap is compared with
+ * the mask color, which is zero in 256-color modes or bright pink for truecolor
+ * data (maximum red and blue, zero green). If the pattern pixel is solid, a
+ * pixel of the color you passed to the drawing routine is written to the
+ * destination bitmap, otherwise a zero is written. The pattern is thus treated
+ * as a monochrome bitmask, which lets you use the same pattern to draw
+ * different shapes in different colors, but prevents the use of multicolored
+ * patterns.
+ *
+ * DRAW_MODE_MASKED_PATTERN is almost the same as DRAW_MODE_SOLID_PATTERN, but
+ * the masked pixels are skipped rather than being written as zeros, so the
+ * background shows through the gaps.
+ *
+ * In DRAW_MODE_TRANS, the global color_map table or truecolor blender functions
+ * are used to overlay pixels on top of the existing image. This must only be
+ * used after you have set up the color mapping table (for 256 color modes) or
+ * blender functions (for truecolor modes). Because it involves reading as well
+ * as writing the bitmap memory, translucent drawing is very slow if you draw
+ * directly to video RAM, so wherever possible you should use a memory bitmap
+ * instead.
+ */
+VALUE a4r_API_drawing_mode(VALUE self, VALUE mode, VALUE pattern, VALUE x_anchor, VALUE y_anchor)
+{
+  BITMAP *bitmap;
+  if (pattern == Qnil)
+    bitmap = NULL;
+  else
+    Data_Get_Struct(pattern, BITMAP, bitmap);
+  drawing_mode(FIX2INT(mode), bitmap, FIX2INT(x_anchor), FIX2INT(y_anchor));
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *   solid_mode -> nil
+ *
+ * This is a shortcut for selecting solid drawing mode. It is equivalent to
+ * calling drawing_mode(DRAW_MODE_SOLID, nil, 0, 0).
+ */
+VALUE a4r_API_solid_mode(VALUE self)
+{
+  solid_mode();
+  return Qnil;
+}

data/ext/a4r_API_truecolor_pixel_formats.c

@@ -0,0 +1,44 @@
+#include "allegro4r.h"
+
+/*
+ * call-seq:
+ *   make_col(r, g, b) -> a_rgb
+ *
+ * Converts colors from a hardware independent format (red, green, and blue
+ * values ranging 0-255) to the pixel format required by the current video mode,
+ * calling the preceding 8, 15, 16, 24, or 32-bit makecol functions as
+ * appropriate. Example:
+ *   # Regardless of color depth, this will look green.
+ *   green_color = makecol(0, 255, 0)
+ *
+ * Return value: Returns the requested RGB triplet in the current color depth.
+ */
+VALUE a4r_API_makecol(VALUE self, VALUE r, VALUE g, VALUE b)
+{
+  return INT2FIX(makecol(FIX2INT(r), FIX2INT(g), FIX2INT(b)));
+}
+
+/*
+ * call-seq:
+ *   palette_color -> ary
+ *
+ * Table mapping palette index colors (0-255) into whatever pixel format is
+ * being used by the current display mode. In a 256-color mode this just maps
+ * onto the array index. In truecolor modes it looks up the specified entry in
+ * the current palette, and converts that RGB value into the appropriate packed
+ * pixel format. Example:
+ *   set_color_depth(32)
+ *   ...
+ *   set_palette(desktop_palette)
+ *   # Put a pixel with the color 2 (green) of the palette
+ *   putpixel(screen, 100, 100, palette_color[2])
+ */
+VALUE a4r_API_palette_color(VALUE self)
+{
+  // TODO: Cache the array, and only update if changed, or use hooked variable?
+  VALUE ary = rb_ary_new2(PAL_SIZE);
+  int x;
+  for (x = 0; x < PAL_SIZE; x++)
+    rb_ary_store(ary, x, INT2FIX(pallete_color[x]));
+  return ary;
+}

data/ext/a4r_API_unicode_routines.c

@@ -0,0 +1,53 @@
+#include "allegro4r.h"
+
+/*
+ * call-seq:
+ *   ustrzncpy(src, n) -> str
+ *
+ * This function is like ustrzcpy except that no more than 'n' characters from
+ * 'src' are copied into 'dest'. If 'src' is shorter than 'n' characters, null
+ * characters are appended to 'dest' as padding until 'n' characters have been
+ * written. In any case, 'dest' is guaranteed to be null-terminated.
+ *
+ * Note that, even for empty strings, your destination string must have at least
+ * enough bytes to store the terminating null character of the string, and your
+ * parameter 'size' must reflect this. Otherwise, the debug version of Allegro
+ * will abort at an assertion, and the release version of Allegro will overrun
+ * the destination buffer.
+ *
+ * Return value: The return value is the value of 'dest'.
+ *
+ * *** The Ruby method signature differs from the Allegro method signature. The
+ * Allegro signature takes a dest by reference, and a size, but the Ruby
+ * signature returns a string containing the dest.  The returned string will
+ * have null characters appended as per the description above.
+ */
+VALUE a4r_API_ustrzncpy(VALUE self, VALUE src, VALUE n)
+{
+  int size = FIX2INT(n) + 1;
+  char *dest = ALLOC_N(char, size);
+  ustrzncpy(dest, size, StringValuePtr(src), size);
+  VALUE s = rb_str_new(dest, size - 1);
+  free(dest);
+  return s;
+}
+
+/*
+ * call-seq:
+ *   usprintf(format) -> str
+ *
+ * This function writes formatted data into the output buffer. A NULL character
+ * is written to mark the end of the string. You should try to avoid this
+ * function because it is very easy to overflow the destination buffer. Use
+ * uszprintf instead.
+ *
+ * Return value: Returns the number of characters written, not including the
+ * terminating null character.
+ *
+ * *** The Ruby method differs from the Allegro method. The Allegro signature
+ * takes a dest but the Ruby signature returns a string containing the dest.
+ */
+VALUE a4r_API_usprintf(VALUE self, VALUE format)
+{
+  return format;
+}

data/ext/a4r_API_using_allegro.c

@@ -0,0 +1,98 @@
+#include "allegro4r.h"
+
+static VALUE a4r_at_exit()
+{
+  rb_funcall(rb_mKernel, rb_intern("at_exit"), 0);
+}
+
+/*
+ * call-seq:
+ *   allegro_init -> int
+ *
+ * Macro which initialises the Allegro library. This is the same thing as
+ * calling install_allegro(SYSTEM_AUTODETECT, &errno, atexit).
+ */
+VALUE a4r_API_allegro_init(VALUE self)
+{
+  int ret = allegro_init();
+  if (!ret)
+    rb_iterate(a4r_at_exit, 0, a4r_API_allegro_exit, self);
+  return INT2FIX(ret);
+}
+
+/*
+ * call-seq:
+ *   allegro_exit -> nil
+ *
+ * Closes down the Allegro system. This includes returning the system to text
+ * mode and removing whatever mouse, keyboard, and timer routines have been
+ * installed. You don't normally need to bother making an explicit call to this
+ * function, because allegro_init installs it as an atexit routine so it will be
+ * called automatically when your program exits.
+ *
+ * Note that after you call this function, other functions like destroy_bitmap
+ * will most likely crash. This is a problem for C++ global destructors, which
+ * usually get called after atexit, so don't put Allegro calls in them. You can
+ * write the destructor code in another method which you can manually call
+ * before your program exits, avoiding this problem.
+ */
+VALUE a4r_API_allegro_exit(VALUE self)
+{
+  allegro_exit();
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *   allegro_error -> str
+ *
+ * Text string used by set_gfx_mode, install_sound and other functions to report
+ * error messages. If they fail and you want to tell the user why, this is the
+ * place to look for a description of the problem. Example:
+ *   def abort_on_error(message)
+ *     set_gfx_mode(GFX_TEXT, 0, 0, 0, 0) unless screen.nil?
+ *
+ *     allegro_message("%s.\nLast Allegro error '%s'\n" %
+ *       [message, allegro_error])
+ *     exit -1
+ *   end
+ *   ...
+ *     if some_allegro_function == ERROR_CODE
+ *       abort_on_error("Error calling some function!")
+ *     end
+ */
+VALUE a4r_API_allegro_error(VALUE self)
+{
+  // TODO: Convert to data struct or cached or hooked variable?
+  return rb_str_new2(allegro_error);
+}
+
+/*
+ * call-seq:
+ *   allegro_message(text) -> nil
+ *
+ * Outputs a message, using a printf format string. Usually you want to use this
+ * to report messages to the user in an OS independant way when some Allegro
+ * subsystem cannot be initialised. But you must not use this function if you
+ * are in a graphic mode, only before calling set_gfx_mode, or after a
+ * set_gfx_mode(GFX_TEXT). Also, this function depends on a system driver being
+ * installed, which means that it won't display the message at all on some
+ * platforms if Allegro has not been initialised correctly.
+ *
+ * On platforms featuring a windowing system, it will bring up a blocking GUI
+ * message box. If there is no windowing system, it will try to print the string
+ * to a text console, attempting to work around codepage differences by reducing
+ * any accented characters to 7-bit ASCII approximations. Example:
+ *   exit 1 if allegro_init != 0
+ *
+ *   if init_my_data != 0
+ *     allegro_message("Sorry, missing game data!\n")
+ *     exit 2
+ *   end
+ */
+VALUE a4r_API_allegro_message(VALUE self, VALUE text)
+{
+  // TODO: Allow parameter possing a lo printf for direct API consistency or force string only?
+  allegro_message(StringValuePtr(text));
+  return Qnil;
+}

data/ext/allegro4r.c

@@ -0,0 +1,866 @@
+/*     ______   ___    ___                               __ __
+ *    /\  _  \ /\_ \  /\_ \                             /\ \\ \
+ *    \ \ \L\ \\//\ \ \//\ \      __     __   _ __   ___\ \ \\ \    _ __
+ *     \ \  __ \ \ \ \  \ \ \   /'__`\ /'_ `\/\`'__\/ __`\ \ \\ \_ /\`'__\
+ *      \ \ \/\ \ \_\ \_ \_\ \_/\  __//\ \L\ \ \ \//\ \L\ \ \__ ,__\ \ \/
+ *       \ \_\ \_\/\____\/\____\ \____\ \____ \ \_\\ \____/\/_/\_\_/\ \_\
+ *        \/_/\/_/\/____/\/____/\/____/\/___L\ \/_/ \/___/    \/_/   \/_/
+ *                                       /\____/
+ *                                       \_/__/
+ *
+ *      Main file for the Allegro4r Ruby binding to the Allegro library.
+ *
+ *      By Jason Frey.
+ */
+
+#include "allegro4r.h"
+
+/*
+ * Document-class: Allegro4r
+ *
+ * The Allegro4r module.
+ */
+VALUE mAllegro4r;
+
+/*
+ * Document-class: Allegro4r::API
+ *
+ * The Allegro4r::API module.
+ */
+VALUE mAllegro4r_API;
+
+/*
+ * Document-class: Allegro4r::API::BITMAP
+ *
+ * Stores the contents of a bitmap.
+ *
+ *   int w, h               - size of the bitmap in pixels
+ *   int clip               - non-zero if clipping is turned on
+ *   int cl, cr, ct, cb     - clip rectangle left, right, top,
+ *                             and bottom
+ *   unsigned char *line[]  - pointers to the start of each line
+ *
+ * There is some other stuff in the structure as well, but it is liable to
+ * change and you shouldn't use anything except the above. The 'w' and 'h'
+ * fields can be used to obtain the size of an existing bitmap:
+ *
+ *   bmp = load_bitmap("file.bmp", pal)
+ *   allegro_message("Bitmap size: (%dx%d)\n" % [bmp.w, bmp.h])
+ *
+ * The clipping rectangle is inclusive on the left and top (0 allows drawing to
+ * position 0) but exclusive on the right and bottom (10 allows drawing to
+ * position 9, but not to 10). Note this is not the same format as that of the
+ * clipping API, which takes inclusive coordinates for all four corners. All the
+ * values of this structure should be regarded as read-only, with the exception
+ * of the line field, whose access is described in depth in the "Direct access
+ * to video memory" section of the manual. If you want to modify the clipping
+ * region, please refrain from changing this structure. Use set_clip_rect
+ * instead.
+ */
+VALUE cAPI_BITMAP;
+
+/*
+ * Document-class: Allegro4r::API::JOYSTICK_INFO
+ *
+ * Stores the contents of joystick information.
+ *
+ * Read chapter "Joystick routines" for a description on how to obtain/use this
+ * structure.
+ */
+VALUE cAPI_JOYSTICK_INFO;
+
+/*
+ * Document-class: Allegro4r::API::JOYSTICK_BUTTON_INFO
+ *
+ * Stores the contents of joystick button information.
+ *
+ * Read chapter "Joystick routines" for a description on how to obtain/use this
+ * structure.
+ */
+VALUE cAPI_JOYSTICK_BUTTON_INFO;
+
+/*
+ * Document-class: Allegro4r::API::JOYSTICK_STICK_INFO
+ *
+ * Stores the contents of joystick stick information.
+ *
+ * Read chapter "Joystick routines" for a description on how to obtain/use this
+ * structure.
+ */
+VALUE cAPI_JOYSTICK_STICK_INFO;
+
+/*
+ * Document-class: Allegro4r::API::JOYSTICK_AXIS_INFO
+ *
+ * Stores the contents of joystick axis information.
+ *
+ * Read chapter "Joystick routines" for a description on how to obtain/use this
+ * structure.
+ */
+VALUE cAPI_JOYSTICK_AXIS_INFO;
+
+/*
+ * Document-class: Allegro4r::API::PALETTE
+ *
+ * Allegro palettes are arrays of PAL_SIZE RGB entries.
+ */
+VALUE cAPI_PALETTE;
+
+/*
+ * Document-class: Allegro4r::API::RGB
+ *   unsigned char r, g, b
+ *
+ * Palette entry. It contains an additional field for the purpose of padding but
+ * you should not usually care about it. Read chapter "Palette routines" for a
+ * description on how to obtain/use this structure.
+ */
+VALUE cAPI_RGB;
+
+/*
+ * Document-class: Allegro4r::API::FONT
+ *
+ * The Allegro4r::API::FONT class.
+ */
+VALUE cAPI_FONT;
+
+/*
+ * Document-class: Allegro4r::API::SAMPLE
+ *
+ *   int bits;                   - 8 or 16
+ *   int stereo;                 - sample type flag
+ *   int freq;                   - sample frequency
+ *   int priority;               - 0-255
+ *   unsigned long len;          - length (in samples)
+ *   unsigned long loop_start;   - loop start position
+ *   unsigned long loop_end;     - loop finish position
+ *   void *data;                 - raw sample data
+ *
+ * A sample structure, which holds sound data, used by the digital sample
+ * routines. You can consider all of these fields as read only except priority,
+ * loop_start and loop_end, which you can change them for example after loading
+ * a sample from disk.
+ *
+ * The priority is a value from 0 to 255 (by default set to 128) and controls
+ * how hardware voices on the sound card are allocated if you attempt to play
+ * more than the driver can handle. This may be used to ensure that the less
+ * important sounds are cut off while the important ones are preserved.
+ *
+ * The variables loop_start and loop_end specify the loop position in sample
+ * units, and are set by default to the start and end of the sample.
+ *
+ * If you are creating your own samples on the fly, you might also want to
+ * modify the raw data of the sample pointed by the data field. The sample data
+ * are always in unsigned format. This means that if you are loading a PCM
+ * encoded sound file with signed 16-bit samples, you would have to XOR every
+ * two bytes (i.e. every sample value) with 0x8000 to change the signedness.
+ */
+VALUE cAPI_SAMPLE;
+
+/*
+ * Document-class: Allegro4r::API::MIDI
+ *
+ * A structure holding MIDI data. Read chapter "Music routines (MIDI)" for a
+ * description on how to obtain/use this structure.
+ */
+VALUE cAPI_MIDI;
+
+/*
+ * Document-class: Allegro4r::API::GFX_DRIVER
+ *
+ * Creates and manages the screen bitmap.
+ */
+VALUE cAPI_GFX_DRIVER;
+
+/*
+ * Document-class: Allegro4r::API::TIMER_DRIVER
+ *
+ * Stores the contents of the timer driver.
+ */
+VALUE cAPI_TIMER_DRIVER;
+
+/*
+ * Document-class: Allegro4r::API::MOUSE_DRIVER
+ *
+ * Stores the contents of the mouse driver.
+ */
+VALUE cAPI_MOUSE_DRIVER;
+
+/*
+ * Document-class: Allegro4r::API::KEYBOARD_DRIVER
+ *
+ * Stores the contents of the keyboard driver.
+ */
+VALUE cAPI_KEYBOARD_DRIVER;
+
+/*
+ * Document-class: Allegro4r::API::JOYSTICK_DRIVER
+ *
+ * Driver for reading joystick input.
+ */
+VALUE cAPI_JOYSTICK_DRIVER;
+
+/*
+ * Document-class: Allegro4r::API::DIGI_DRIVER
+ *
+ * Driver for playing digital sfx.
+ */
+VALUE cAPI_DIGI_DRIVER;
+
+/*
+ * Document-class: Allegro4r::API::MIDI_DRIVER
+ *
+ * Driver for playing midi music.
+ */
+VALUE cAPI_MIDI_DRIVER;
+
+ID CALL_ID;
+
+void Init_allegro4r()
+{
+  CALL_ID = rb_intern("call");
+
+  mAllegro4r = rb_define_module("Allegro4r");
+  mAllegro4r_API = rb_define_module_under(mAllegro4r, "API");
+
+  cAPI_BITMAP = rb_define_class_under(mAllegro4r_API, "BITMAP", rb_cObject); // in a4r_API_BITMAP.c
+  rb_define_method(cAPI_BITMAP, "h", a4r_API_BITMAP_h_get, 0); // in a4r_API_BITMAP.c
+  rb_define_method(cAPI_BITMAP, "w", a4r_API_BITMAP_w_get, 0); // in a4r_API_BITMAP.c
+
+  cAPI_JOYSTICK_INFO = rb_define_class_under(mAllegro4r_API, "JOYSTICK_INFO", rb_cObject); // in a4r_API_JOYSTICK_INFO.c
+  rb_define_method(cAPI_JOYSTICK_INFO, "flags", a4r_API_JOYSTICK_INFO_flags, 0); // in a4r_API_JOYSTICK_INFO.c
+  rb_define_method(cAPI_JOYSTICK_INFO, "num_sticks", a4r_API_JOYSTICK_INFO_num_sticks, 0); // in a4r_API_JOYSTICK_INFO.c
+  rb_define_method(cAPI_JOYSTICK_INFO, "num_buttons", a4r_API_JOYSTICK_INFO_num_buttons, 0); // in a4r_API_JOYSTICK_INFO.c
+  rb_define_method(cAPI_JOYSTICK_INFO, "stick", a4r_API_JOYSTICK_INFO_stick, 0); // in a4r_API_JOYSTICK_INFO.c
+  rb_define_method(cAPI_JOYSTICK_INFO, "button", a4r_API_JOYSTICK_INFO_button, 0); // in a4r_API_JOYSTICK_INFO.c
+
+  cAPI_JOYSTICK_BUTTON_INFO = rb_define_class_under(mAllegro4r_API, "JOYSTICK_BUTTON_INFO", rb_cObject); // in a4r_API_JOYSTICK_BUTTON_INFO.c
+  rb_define_method(cAPI_JOYSTICK_BUTTON_INFO, "b", a4r_API_JOYSTICK_BUTTON_INFO_b, 0); // in a4r_API_JOYSTICK_BUTTON_INFO.c
+  rb_define_method(cAPI_JOYSTICK_BUTTON_INFO, "name", a4r_API_JOYSTICK_BUTTON_INFO_name, 0); // in a4r_API_JOYSTICK_BUTTON_INFO.c
+
+  cAPI_JOYSTICK_STICK_INFO = rb_define_class_under(mAllegro4r_API, "JOYSTICK_STICK_INFO", rb_cObject); // in a4r_API_JOYSTICK_STICK_INFO.c
+  rb_define_method(cAPI_JOYSTICK_STICK_INFO, "flags", a4r_API_JOYSTICK_STICK_INFO_flags, 0); // in a4r_API_JOYSTICK_STICK_INFO.c
+  rb_define_method(cAPI_JOYSTICK_STICK_INFO, "num_axis", a4r_API_JOYSTICK_STICK_INFO_num_axis, 0); // in a4r_API_JOYSTICK_STICK_INFO.c
+  rb_define_method(cAPI_JOYSTICK_STICK_INFO, "axis", a4r_API_JOYSTICK_STICK_INFO_axis, 0); // in a4r_API_JOYSTICK_STICK_INFO.c
+  rb_define_method(cAPI_JOYSTICK_STICK_INFO, "name", a4r_API_JOYSTICK_STICK_INFO_name, 0); // in a4r_API_JOYSTICK_STICK_INFO.c
+
+  cAPI_JOYSTICK_AXIS_INFO = rb_define_class_under(mAllegro4r_API, "JOYSTICK_AXIS_INFO", rb_cObject); // in a4r_API_JOYSTICK_AXIS_INFO.c
+  rb_define_method(cAPI_JOYSTICK_AXIS_INFO, "pos", a4r_API_JOYSTICK_AXIS_INFO_pos, 0); // in a4r_API_JOYSTICK_AXIS_INFO.c
+  rb_define_method(cAPI_JOYSTICK_AXIS_INFO, "d1", a4r_API_JOYSTICK_AXIS_INFO_d1, 0); // in a4r_API_JOYSTICK_AXIS_INFO.c
+  rb_define_method(cAPI_JOYSTICK_AXIS_INFO, "d2", a4r_API_JOYSTICK_AXIS_INFO_d2, 0); // in a4r_API_JOYSTICK_AXIS_INFO.c
+  rb_define_method(cAPI_JOYSTICK_AXIS_INFO, "name", a4r_API_JOYSTICK_AXIS_INFO_name, 0); // in a4r_API_JOYSTICK_AXIS_INFO.c
+
+  cAPI_PALETTE = rb_define_class_under(mAllegro4r_API, "PALETTE", rb_cObject); // in a4r_API_PALETTE.c
+  rb_define_alloc_func(cAPI_PALETTE, a4r_API_PALETTE_alloc); // in a4r_API_PALETTE.c
+  rb_define_method(cAPI_PALETTE, "initialize_copy", a4r_API_PALETTE_initialize_copy, 1); // in a4r_API_PALETTE.c
+  rb_define_method(cAPI_PALETTE, "[]", a4r_API_PALETTE_getter, 1); // in a4r_API_PALETTE.c
+  rb_define_method(cAPI_PALETTE, "[]=", a4r_API_PALETTE_setter, 2); // in a4r_API_PALETTE.c
+
+  cAPI_RGB = rb_define_class_under(mAllegro4r_API, "RGB", rb_cObject); // in a4r_API_RGB.c
+  rb_define_alloc_func(cAPI_RGB, a4r_API_RGB_alloc); // in a4r_API_RGB.c
+  rb_define_method(cAPI_RGB, "initialize_copy", a4r_API_RGB_initialize_copy, 1); // in a4r_API_RGB.c
+  rb_define_method(cAPI_RGB, "r", a4r_API_RGB_r_get, 0); // in a4r_API_RGB.c
+  rb_define_method(cAPI_RGB, "r=", a4r_API_RGB_r_set, 1); // in a4r_API_RGB.c
+  rb_define_method(cAPI_RGB, "g", a4r_API_RGB_g_get, 0); // in a4r_API_RGB.c
+  rb_define_method(cAPI_RGB, "g=", a4r_API_RGB_g_set, 1); // in a4r_API_RGB.c
+  rb_define_method(cAPI_RGB, "b", a4r_API_RGB_b_get, 0); // in a4r_API_RGB.c
+  rb_define_method(cAPI_RGB, "b=", a4r_API_RGB_b_set, 1); // in a4r_API_RGB.c
+
+  cAPI_FONT = rb_define_class_under(mAllegro4r_API, "FONT", rb_cObject);
+
+  cAPI_SAMPLE = rb_define_class_under(mAllegro4r_API, "SAMPLE", rb_cObject);
+
+  cAPI_MIDI = rb_define_class_under(mAllegro4r_API, "MIDI", rb_cObject);
+
+  cAPI_GFX_DRIVER = rb_define_class_under(mAllegro4r_API, "GFX_DRIVER", rb_cObject); // in a4r_API_GFX_DRIVER.c
+  rb_define_method(cAPI_GFX_DRIVER, "name", a4r_API_GFX_DRIVER_name_get, 0); // in a4r_API_GFX_DRIVER.c
+
+  cAPI_MOUSE_DRIVER = rb_define_class_under(mAllegro4r_API, "MOUSE_DRIVER", rb_cObject); // in a4r_API_MOUSE_DRIVER.c
+  rb_define_method(cAPI_MOUSE_DRIVER, "name", a4r_API_MOUSE_DRIVER_name_get, 0); // in a4r_API_MOUSE_DRIVER.c
+
+  cAPI_TIMER_DRIVER = rb_define_class_under(mAllegro4r_API, "TIMER_DRIVER", rb_cObject); // in a4r_API_TIMER_DRIVER.c
+  rb_define_method(cAPI_TIMER_DRIVER, "name", a4r_API_TIMER_DRIVER_name_get, 0); // in a4r_API_TIMER_DRIVER.c
+
+  cAPI_KEYBOARD_DRIVER = rb_define_class_under(mAllegro4r_API, "KEYBOARD_DRIVER", rb_cObject); // in a4r_API_KEYBOARD_DRIVER.c
+  rb_define_method(cAPI_KEYBOARD_DRIVER, "name", a4r_API_KEYBOARD_DRIVER_name_get, 0); // in a4r_API_KEYBOARD_DRIVER.c
+
+  cAPI_JOYSTICK_DRIVER = rb_define_class_under(mAllegro4r_API, "JOYSTICK_DRIVER", rb_cObject); // in a4r_API_JOYSTICK_DRIVER.c
+  rb_define_method(cAPI_JOYSTICK_DRIVER, "name", a4r_API_JOYSTICK_DRIVER_name_get, 0); // in a4r_API_JOYSTICK_DRIVER.c
+
+  cAPI_DIGI_DRIVER = rb_define_class_under(mAllegro4r_API, "DIGI_DRIVER", rb_cObject); // in a4r_API_DIGI_DRIVER.c
+  rb_define_method(cAPI_DIGI_DRIVER, "name", a4r_API_DIGI_DRIVER_name_get, 0); // in a4r_API_DIGI_DRIVER.c
+
+  cAPI_MIDI_DRIVER = rb_define_class_under(mAllegro4r_API, "MIDI_DRIVER", rb_cObject); // in a4r_API_MIDI_DRIVER.c
+  rb_define_method(cAPI_MIDI_DRIVER, "name", a4r_API_MIDI_DRIVER_name_get, 0); // in a4r_API_MIDI_DRIVER.c
+
+  rb_define_module_function(mAllegro4r_API, "MIN", a4r_API_MIN, 2); // in a4r_API_misc.c
+  rb_define_module_function(mAllegro4r_API, "ABS", a4r_API_ABS, 1); // in a4r_API_misc.c
+  rb_define_module_function(mAllegro4r_API, "AL_RAND", a4r_API_AL_RAND, 0); // in a4r_API_misc.c
+  rb_define_module_function(mAllegro4r_API, "gfx_driver", a4r_API_gfx_driver, 0); // in a4r_API_misc.c
+  rb_define_module_function(mAllegro4r_API, "mouse_driver", a4r_API_mouse_driver, 0); // in a4r_API_misc.c
+  rb_define_module_function(mAllegro4r_API, "timer_driver", a4r_API_timer_driver, 0); // in a4r_API_misc.c
+  rb_define_module_function(mAllegro4r_API, "keyboard_driver", a4r_API_keyboard_driver, 0); // in a4r_API_misc.c
+  rb_define_module_function(mAllegro4r_API, "joystick_driver", a4r_API_joystick_driver, 0); // in a4r_API_misc.c
+  rb_define_module_function(mAllegro4r_API, "digi_driver", a4r_API_digi_driver, 0); // in a4r_API_misc.c
+  rb_define_module_function(mAllegro4r_API, "midi_driver", a4r_API_midi_driver, 0); // in a4r_API_misc.c
+
+  rb_define_module_function(mAllegro4r_API, "allegro_init", a4r_API_allegro_init, 0); // in a4r_API_using_allegro.c
+  rb_define_module_function(mAllegro4r_API, "allegro_exit", a4r_API_allegro_exit, 0); // in a4r_API_using_allegro.c
+  rb_define_module_function(mAllegro4r_API, "allegro_error", a4r_API_allegro_error, 0); // in a4r_API_using_allegro.c
+  rb_define_module_function(mAllegro4r_API, "allegro_message", a4r_API_allegro_message, 1); // in a4r_API_using_allegro.c
+
+  rb_define_module_function(mAllegro4r_API, "ustrzncpy", a4r_API_ustrzncpy, 2); // in a4r_API_unicode_routines.c
+  rb_define_module_function(mAllegro4r_API, "usprintf", a4r_API_usprintf, 1); // in a4r_API_unicode_routines.c
+
+  rb_define_module_function(mAllegro4r_API, "install_mouse", a4r_API_install_mouse, 0); // in a4r_API_mouse_routines.c
+  rb_define_module_function(mAllegro4r_API, "poll_mouse", a4r_API_poll_mouse, 0); // in a4r_API_mouse_routines.c
+  rb_define_module_function(mAllegro4r_API, "mouse_x", a4r_API_mouse_x, 0); // in a4r_API_mouse_routines.c
+  rb_define_module_function(mAllegro4r_API, "mouse_y", a4r_API_mouse_y, 0); // in a4r_API_mouse_routines.c
+  rb_define_module_function(mAllegro4r_API, "mouse_z", a4r_API_mouse_z, 0); // in a4r_API_mouse_routines.c
+  rb_define_module_function(mAllegro4r_API, "mouse_w", a4r_API_mouse_w, 0); // in a4r_API_mouse_routines.c
+  rb_define_module_function(mAllegro4r_API, "mouse_b", a4r_API_mouse_b, 0); // in a4r_API_mouse_routines.c
+  rb_define_module_function(mAllegro4r_API, "show_mouse", a4r_API_show_mouse, 1); // in a4r_API_mouse_routines.c
+  rb_define_module_function(mAllegro4r_API, "get_mouse_mickeys", a4r_API_get_mouse_mickeys, 0); // in a4r_API_mouse_routines.c
+  rb_define_module_function(mAllegro4r_API, "set_mouse_sprite", a4r_API_set_mouse_sprite, 1); // in a4r_API_mouse_routines.c
+  rb_define_module_function(mAllegro4r_API, "set_mouse_sprite_focus", a4r_API_set_mouse_sprite_focus, 2); // in a4r_API_mouse_routines.c
+
+  rb_define_module_function(mAllegro4r_API, "install_timer", a4r_API_install_timer, 0); // in a4r_API_timer_routines.c
+  rb_define_module_function(mAllegro4r_API, "install_int", a4r_API_install_int, 2); // in a4r_API_timer_routines.c
+  rb_define_module_function(mAllegro4r_API, "install_int_ex", a4r_API_install_int_ex, 2); // in a4r_API_timer_routines.c
+  rb_define_module_function(mAllegro4r_API, "LOCK_VARIABLE", a4r_API_LOCK_VARIABLE, 1); // in a4r_API_timer_routines.c
+  rb_define_module_function(mAllegro4r_API, "LOCK_FUNCTION", a4r_API_LOCK_FUNCTION, 1); // in a4r_API_timer_routines.c
+  rb_define_module_function(mAllegro4r_API, "retrace_count", a4r_API_retrace_count, 0); // in a4r_API_timer_routines.c
+  rb_define_module_function(mAllegro4r_API, "rest", a4r_API_rest, 1); // in a4r_API_timer_routines.c
+  rb_define_module_function(mAllegro4r_API, "SECS_TO_TIMER", a4r_API_SECS_TO_TIMER, 1); // in a4r_API_timer_routines.c
+  rb_define_module_function(mAllegro4r_API, "MSEC_TO_TIMER", a4r_API_MSEC_TO_TIMER, 1); // in a4r_API_timer_routines.c
+  rb_define_module_function(mAllegro4r_API, "BPS_TO_TIMER", a4r_API_BPS_TO_TIMER, 1); // in a4r_API_timer_routines.c
+  rb_define_module_function(mAllegro4r_API, "BPM_TO_TIMER", a4r_API_BPM_TO_TIMER, 1); // in a4r_API_timer_routines.c
+
+  timer_counter_names = rb_hash_new();
+  rb_global_variable(&timer_counter_names);
+  LOCK_VARIABLE(timer_counters)
+  LOCK_FUNCTION(timer_counter_incr)
+  rb_define_module_function(mAllegro4r_API, "timer_counter_get", a4r_API_timer_counter_get, 1); // in a4r_API_timer_routines.c
+
+  rb_define_module_function(mAllegro4r_API, "install_keyboard", a4r_API_install_keyboard, 0); // in a4r_API_keyboard_routines.c
+  rb_define_module_function(mAllegro4r_API, "poll_keyboard", a4r_API_poll_keyboard, 0); // in a4r_API_keyboard_routines.c
+  rb_define_module_function(mAllegro4r_API, "key", a4r_API_key, 0); // in a4r_API_keyboard_routines.c
+  rb_define_module_function(mAllegro4r_API, "key_shifts", a4r_API_key_shifts, 0); // in a4r_API_keyboard_routines.c
+  rb_define_module_function(mAllegro4r_API, "keypressed", a4r_API_keypressed, 0); // in a4r_API_keyboard_routines.c
+  rb_define_module_function(mAllegro4r_API, "readkey", a4r_API_readkey, 0); // in a4r_API_keyboard_routines.c
+  rb_define_module_function(mAllegro4r_API, "ureadkey", a4r_API_ureadkey, 1); // in a4r_API_keyboard_routines.c
+  rb_define_module_function(mAllegro4r_API, "scancode_to_name", a4r_API_scancode_to_name, 1); // in a4r_API_keyboard_routines.c
+  rb_define_module_function(mAllegro4r_API, "keyboard_callback=", a4r_API_keyboard_callback_set, 1); // in a4r_API_keyboard_routines.c
+  rb_define_module_function(mAllegro4r_API, "keyboard_lowlevel_callback=", a4r_API_keyboard_lowlevel_callback_set, 1); // in a4r_API_keyboard_routines.c
+  rb_define_module_function(mAllegro4r_API, "clear_keybuf", a4r_API_clear_keybuf, 0); // in a4r_API_keyboard_routines.c
+
+  rb_global_variable(&keyboard_callback_proc);
+  rb_global_variable(&keyboard_lowlevel_callback_proc);
+  LOCK_VARIABLE(keyboard_callback_proc)
+  LOCK_VARIABLE(keyboard_lowlevel_callback_proc)
+  LOCK_FUNCTION(keyboard_callback_method)
+  LOCK_FUNCTION(keyboard_lowlevel_callback_method)
+
+  rb_define_module_function(mAllegro4r_API, "install_joystick", a4r_API_install_joystick, 1); // in a4r_API_joystick_routines.c
+  rb_define_module_function(mAllegro4r_API, "poll_joystick", a4r_API_poll_joystick, 0); // in a4r_API_joystick_routines.c
+  rb_define_module_function(mAllegro4r_API, "num_joysticks", a4r_API_num_joysticks, 0); // in a4r_API_joystick_routines.c
+  rb_define_module_function(mAllegro4r_API, "joy", a4r_API_joy, 0); // in a4r_API_joystick_routines.c
+  rb_define_module_function(mAllegro4r_API, "calibrate_joystick_name", a4r_API_calibrate_joystick_name, 1); // in a4r_API_joystick_routines.c
+  rb_define_module_function(mAllegro4r_API, "calibrate_joystick", a4r_API_calibrate_joystick, 1); // in a4r_API_joystick_routines.c
+
+  rb_define_module_function(mAllegro4r_API, "set_gfx_mode", a4r_API_set_gfx_mode, 5); // in a4r_API_graphics_modes.c
+  rb_define_module_function(mAllegro4r_API, "set_display_switch_mode", a4r_API_set_display_switch_mode, 1); // in a4r_API_graphics_modes.c
+  rb_define_module_function(mAllegro4r_API, "show_video_bitmap", a4r_API_show_video_bitmap, 1); // in a4r_API_graphics_modes.c
+  rb_define_module_function(mAllegro4r_API, "vsync", a4r_API_vsync, 0); // in a4r_API_graphics_modes.c
+
+  rb_define_module_function(mAllegro4r_API, "screen", a4r_API_screen, 0); // in a4r_API_bitmap_objects.c
+  rb_define_module_function(mAllegro4r_API, "SCREEN_W", a4r_API_SCREEN_W, 0); // in a4r_API_bitmap_objects.c
+  rb_define_module_function(mAllegro4r_API, "SCREEN_H", a4r_API_SCREEN_H, 0); // in a4r_API_bitmap_objects.c
+  rb_define_module_function(mAllegro4r_API, "create_bitmap", a4r_API_create_bitmap, 2); // in a4r_API_bitmap_objects.c
+  rb_define_module_function(mAllegro4r_API, "create_sub_bitmap", a4r_API_create_sub_bitmap, 5); // in a4r_API_bitmap_objects.c
+  rb_define_module_function(mAllegro4r_API, "create_video_bitmap", a4r_API_create_video_bitmap, 2); // in a4r_API_bitmap_objects.c
+  rb_define_module_function(mAllegro4r_API, "destroy_bitmap", a4r_API_destroy_bitmap, 1); // in a4r_API_bitmap_objects.c
+  rb_define_module_function(mAllegro4r_API, "bitmap_mask_color", a4r_API_bitmap_mask_color, 1); // in a4r_API_bitmap_objects.c
+  rb_define_module_function(mAllegro4r_API, "acquire_bitmap", a4r_API_acquire_bitmap, 1); // in a4r_API_bitmap_objects.c
+  rb_define_module_function(mAllegro4r_API, "release_bitmap", a4r_API_release_bitmap, 1); // in a4r_API_bitmap_objects.c
+  rb_define_module_function(mAllegro4r_API, "acquire_screen", a4r_API_acquire_screen, 0); // in a4r_API_bitmap_objects.c
+  rb_define_module_function(mAllegro4r_API, "release_screen", a4r_API_release_screen, 0); // in a4r_API_bitmap_objects.c
+
+  rb_define_module_function(mAllegro4r_API, "set_palette", a4r_API_set_palette, 1); // in a4r_API_palette_routines.c
+  rb_define_module_function(mAllegro4r_API, "get_palette", a4r_API_get_palette, 1); // in a4r_API_palette_routines.c
+  rb_define_module_function(mAllegro4r_API, "default_palette", a4r_API_default_palette, 0); // in a4r_API_palette_routines.c
+  rb_define_module_function(mAllegro4r_API, "black_palette", a4r_API_black_palette, 0); // in a4r_API_palette_routines.c
+  rb_define_module_function(mAllegro4r_API, "desktop_palette", a4r_API_desktop_palette, 0); // in a4r_API_palette_routines.c
+
+  rb_define_module_function(mAllegro4r_API, "makecol", a4r_API_makecol, 3); // in a4r_API_truecolor_pixel_formats.c
+  rb_define_module_function(mAllegro4r_API, "palette_color", a4r_API_palette_color, 0); // in a4r_API_truecolor_pixel_formats.c
+
+  rb_define_module_function(mAllegro4r_API, "clear_bitmap", a4r_API_clear_bitmap, 1); // in a4r_API_drawing_primitives.c
+  rb_define_module_function(mAllegro4r_API, "clear_to_color", a4r_API_clear_to_color, 2); // in a4r_API_drawing_primitives.c
+  rb_define_module_function(mAllegro4r_API, "putpixel", a4r_API_putpixel, 4); // in a4r_API_drawing_primitives.c
+  rb_define_module_function(mAllegro4r_API, "getpixel", a4r_API_getpixel, 3); // in a4r_API_drawing_primitives.c
+  rb_define_module_function(mAllegro4r_API, "rectfill", a4r_API_rectfill, 6); // in a4r_API_drawing_primitives.c
+  rb_define_module_function(mAllegro4r_API, "circle", a4r_API_circle, 5); // in a4r_API_drawing_primitives.c
+  rb_define_module_function(mAllegro4r_API, "circlefill", a4r_API_circlefill, 5); // in a4r_API_drawing_primitives.c
+
+  rb_define_module_function(mAllegro4r_API, "blit", a4r_API_blit, 8); // in a4r_API_blitting_and_sprites.c
+  rb_define_module_function(mAllegro4r_API, "masked_blit", a4r_API_masked_blit, 8); // in a4r_API_blitting_and_sprites.c
+
+  rb_define_module_function(mAllegro4r_API, "load_font", a4r_API_load_font, 3); // in a4r_API_fonts.c
+  rb_define_module_function(mAllegro4r_API, "destroy_font", a4r_API_destroy_font, 1); // in a4r_API_fonts.c
+  rb_define_module_function(mAllegro4r_API, "extract_font_range", a4r_API_extract_font_range, 3); // in a4r_API_fonts.c
+  rb_define_module_function(mAllegro4r_API, "merge_fonts", a4r_API_merge_fonts, 2); // in a4r_API_fonts.c
+
+  rb_define_module_function(mAllegro4r_API, "font", a4r_API_font, 0); // in a4r_API_text_output.c
+  rb_define_module_function(mAllegro4r_API, "font=", a4r_API_font_set, 1); // in a4r_API_text_output.c
+  rb_define_module_function(mAllegro4r_API, "text_length", a4r_API_text_length, 2); // in a4r_API_text_output.c
+  rb_define_module_function(mAllegro4r_API, "text_height", a4r_API_text_height, 1); // in a4r_API_text_output.c
+  rb_define_module_function(mAllegro4r_API, "textout_ex", a4r_API_textout_ex, 7); // in a4r_API_text_output.c
+  rb_define_module_function(mAllegro4r_API, "textout_centre_ex", a4r_API_textout_centre_ex, 7); // in a4r_API_text_output.c
+  rb_define_module_function(mAllegro4r_API, "textprintf_ex", a4r_API_textprintf_ex, 7); // in a4r_API_text_output.c
+  rb_define_module_function(mAllegro4r_API, "textprintf_centre_ex", a4r_API_textprintf_centre_ex, 7); // in a4r_API_text_output.c
+  rb_define_module_function(mAllegro4r_API, "textprintf_right_ex", a4r_API_textprintf_right_ex, 7); // in a4r_API_text_output.c
+
+  rb_define_module_function(mAllegro4r_API, "drawing_mode", a4r_API_drawing_mode, 4); // in a4r_API_transparency_and_patterned_drawing.c
+  rb_define_module_function(mAllegro4r_API, "solid_mode", a4r_API_solid_mode, 0); // in a4r_API_transparency_and_patterned_drawing.c
+
+  rb_define_module_function(mAllegro4r_API, "bmp_select", a4r_API_bmp_select, 1); // in a4r_API_direct_access_to_video_memory.c
+  rb_define_module_function(mAllegro4r_API, "bmp_read8", a4r_API_bmp_read8, 1); // in a4r_API_direct_access_to_video_memory.c
+  rb_define_module_function(mAllegro4r_API, "bmp_read32", a4r_API_bmp_read32, 1); // in a4r_API_direct_access_to_video_memory.c
+  rb_define_module_function(mAllegro4r_API, "bmp_write8", a4r_API_bmp_write8, 2); // in a4r_API_direct_access_to_video_memory.c
+  rb_define_module_function(mAllegro4r_API, "bmp_write32", a4r_API_bmp_write32, 2); // in a4r_API_direct_access_to_video_memory.c
+  rb_define_module_function(mAllegro4r_API, "bmp_write_line", a4r_API_bmp_write_line, 2); // in a4r_API_direct_access_to_video_memory.c
+  rb_define_module_function(mAllegro4r_API, "bmp_read_line", a4r_API_bmp_read_line, 2); // in a4r_API_direct_access_to_video_memory.c
+  rb_define_module_function(mAllegro4r_API, "bmp_unwrite_line", a4r_API_bmp_unwrite_line, 1); // in a4r_API_direct_access_to_video_memory.c
+
+  rb_define_module_function(mAllegro4r_API, "install_sound", a4r_API_install_sound, 3); // in a4r_API_sound_init_routines.c
+
+  rb_define_module_function(mAllegro4r_API, "load_sample", a4r_API_load_sample, 1); // in a4r_API_digital_sample_routines.c
+  rb_define_module_function(mAllegro4r_API, "destroy_sample", a4r_API_destroy_sample, 1); // in a4r_API_digital_sample_routines.c
+  rb_define_module_function(mAllegro4r_API, "play_sample", a4r_API_play_sample, 5); // in a4r_API_digital_sample_routines.c
+  rb_define_module_function(mAllegro4r_API, "adjust_sample", a4r_API_adjust_sample, 5); // in a4r_API_digital_sample_routines.c
+
+  rb_define_module_function(mAllegro4r_API, "load_midi", a4r_API_load_midi, 1); // in a4r_API_music_routines_midi.c
+  rb_define_module_function(mAllegro4r_API, "destroy_midi", a4r_API_destroy_midi, 1); // in a4r_API_music_routines_midi.c
+  rb_define_module_function(mAllegro4r_API, "play_midi", a4r_API_play_midi, 2); // in a4r_API_music_routines_midi.c
+  rb_define_module_function(mAllegro4r_API, "midi_pause", a4r_API_midi_pause, 0); // in a4r_API_music_routines_midi.c
+  rb_define_module_function(mAllegro4r_API, "midi_resume", a4r_API_midi_resume, 0); // in a4r_API_music_routines_midi.c
+  rb_define_module_function(mAllegro4r_API, "get_midi_length", a4r_API_get_midi_length, 1); // in a4r_API_music_routines_midi.c
+  rb_define_module_function(mAllegro4r_API, "midi_pos", a4r_API_midi_pos, 0); // in a4r_API_music_routines_midi.c
+  rb_define_module_function(mAllegro4r_API, "midi_time", a4r_API_midi_time, 0); // in a4r_API_music_routines_midi.c
+
+  rb_define_module_function(mAllegro4r_API, "get_filename", a4r_API_get_filename, 1); // in a4r_API_file_and_compression_routines.c
+
+  rb_define_module_function(mAllegro4r_API, "itofix", a4r_API_itofix, 1); // in a4r_API_fixed_point_math_routines.c
+  rb_define_module_function(mAllegro4r_API, "ftofix", a4r_API_ftofix, 1); // in a4r_API_fixed_point_math_routines.c
+  rb_define_module_function(mAllegro4r_API, "fixtof", a4r_API_fixtof, 1); // in a4r_API_fixed_point_math_routines.c
+  rb_define_module_function(mAllegro4r_API, "fixmul", a4r_API_fixmul, 2); // in a4r_API_fixed_point_math_routines.c
+  rb_define_module_function(mAllegro4r_API, "fixsqrt", a4r_API_fixsqrt, 1); // in a4r_API_fixed_point_math_routines.c
+
+  /*
+   * GFX_AUTODETECT: Allegro will try to set the specified resolution with the
+   * current color depth in fullscreen mode. Failing that, it will try to repeat
+   * the same operation in windowed mode.
+   */
+  rb_define_const(mAllegro4r_API, "GFX_AUTODETECT", INT2FIX(GFX_AUTODETECT));
+  /*
+   * GFX_AUTODETECT_FULLSCREEN: Allegro will try to set the specified resolution
+   * with the current color depth in fullscreen mode.
+   */
+  rb_define_const(mAllegro4r_API, "GFX_AUTODETECT_FULLSCREEN", INT2FIX(GFX_AUTODETECT_FULLSCREEN));
+  /*
+   * GFX_AUTODETECT_WINDOWED: Allegro will try to set the specified resolution
+   * with the current color depth in a windowed mode.
+   */
+  rb_define_const(mAllegro4r_API, "GFX_AUTODETECT_WINDOWED", INT2FIX(GFX_AUTODETECT_WINDOWED));
+  /*
+   * GFX_SAFE: Allegro will try to set the specified resolution. Failing that,
+   * it will fall back upon whatever mode is known to be reliable on the current
+   * platform. If it absolutely cannot set any graphics mode at all, there's no
+   * possible video output on the machine.
+   */
+  rb_define_const(mAllegro4r_API, "GFX_SAFE", INT2NUM(GFX_SAFE));
+  /*
+   * GFX_TEXT: Closes any previously opened graphics mode, and in those
+   * environments that have text modes, sets one previously used or the closest
+   * match to that (usually 80x25).
+   */
+  rb_define_const(mAllegro4r_API, "GFX_TEXT", INT2FIX(GFX_TEXT));
+
+  /* SWITCH_NONE: Disables switching. */
+  rb_define_const(mAllegro4r_API, "SWITCH_NONE", INT2FIX(SWITCH_NONE));
+  /* SWITCH_PAUSE: Pauses the program whenever it is in the background. */
+  rb_define_const(mAllegro4r_API, "SWITCH_PAUSE", INT2FIX(SWITCH_PAUSE));
+  /* 
+   * SWITCH_AMNESIA: Like SWITCH_PAUSE, but this mode doesn't bother to remember
+   * the contents of video memory, so the screen, and any video bitmaps that you
+   * have created, will be erased after the user switches away and then back to
+   * your program
+   */
+  rb_define_const(mAllegro4r_API, "SWITCH_AMNESIA", INT2FIX(SWITCH_AMNESIA));
+  /* 
+   * SWITCH_BACKGROUND: The program will carry on running in the background,
+   * with the screen bitmap temporarily being pointed at a memory buffer for the
+   * fullscreen drivers
+   */
+  rb_define_const(mAllegro4r_API, "SWITCH_BACKGROUND", INT2FIX(SWITCH_BACKGROUND));
+  /* 
+   * SWITCH_BACKAMNESIA: Like SWITCH_BACKGROUND, but this mode doesn't bother to
+   * remember the contents of video memory
+   */
+  rb_define_const(mAllegro4r_API, "SWITCH_BACKAMNESIA", INT2FIX(SWITCH_BACKAMNESIA));
+
+  /* DRAW_MODE_SOLID: The default, solid color drawing */
+  rb_define_const(mAllegro4r_API, "DRAW_MODE_SOLID", INT2FIX(DRAW_MODE_SOLID));
+  /* DRAW_MODE_XOR: Exclusive-or drawing */
+  rb_define_const(mAllegro4r_API, "DRAW_MODE_XOR", INT2FIX(DRAW_MODE_XOR));
+  /* DRAW_MODE_COPY_PATTERN: Multicolored pattern fill */
+  rb_define_const(mAllegro4r_API, "DRAW_MODE_COPY_PATTERN", INT2FIX(DRAW_MODE_COPY_PATTERN));
+  /* DRAW_MODE_SOLID_PATTERN: Single color pattern fill */
+  rb_define_const(mAllegro4r_API, "DRAW_MODE_SOLID_PATTERN", INT2FIX(DRAW_MODE_SOLID_PATTERN));
+  /* DRAW_MODE_MASKED_PATTERN: Masked pattern fill */
+  rb_define_const(mAllegro4r_API, "DRAW_MODE_MASKED_PATTERN", INT2FIX(DRAW_MODE_MASKED_PATTERN));
+  /* DRAW_MODE_TRANS: Translucent color blending */
+  rb_define_const(mAllegro4r_API, "DRAW_MODE_TRANS", INT2FIX(DRAW_MODE_TRANS));
+
+  /* KB_SHIFT_FLAG: */
+  rb_define_const(mAllegro4r_API, "KB_SHIFT_FLAG", INT2FIX(KB_SHIFT_FLAG));
+  /* KB_CTRL_FLAG: */
+  rb_define_const(mAllegro4r_API, "KB_CTRL_FLAG", INT2FIX(KB_CTRL_FLAG));
+  /* KB_ALT_FLAG: */
+  rb_define_const(mAllegro4r_API, "KB_ALT_FLAG", INT2FIX(KB_ALT_FLAG));
+  /* KB_LWIN_FLAG: */
+  rb_define_const(mAllegro4r_API, "KB_LWIN_FLAG", INT2FIX(KB_LWIN_FLAG));
+  /* KB_RWIN_FLAG: */
+  rb_define_const(mAllegro4r_API, "KB_RWIN_FLAG", INT2FIX(KB_RWIN_FLAG));
+  /* KB_MENU_FLAG: */
+  rb_define_const(mAllegro4r_API, "KB_MENU_FLAG", INT2FIX(KB_MENU_FLAG));
+  /* KB_COMMAND_FLAG: */
+  rb_define_const(mAllegro4r_API, "KB_COMMAND_FLAG", INT2FIX(KB_COMMAND_FLAG));
+  /* KB_SCROLOCK_FLAG: */
+  rb_define_const(mAllegro4r_API, "KB_SCROLOCK_FLAG", INT2FIX(KB_SCROLOCK_FLAG));
+  /* KB_NUMLOCK_FLAG: */
+  rb_define_const(mAllegro4r_API, "KB_NUMLOCK_FLAG", INT2FIX(KB_NUMLOCK_FLAG));
+  /* KB_CAPSLOCK_FLAG: */
+  rb_define_const(mAllegro4r_API, "KB_CAPSLOCK_FLAG", INT2FIX(KB_CAPSLOCK_FLAG));
+  /* KB_INALTSEQ_FLAG: */
+  rb_define_const(mAllegro4r_API, "KB_INALTSEQ_FLAG", INT2FIX(KB_INALTSEQ_FLAG));
+  /* KB_ACCENT1_FLAG: */
+  rb_define_const(mAllegro4r_API, "KB_ACCENT1_FLAG", INT2FIX(KB_ACCENT1_FLAG));
+  /* KB_ACCENT2_FLAG: */
+  rb_define_const(mAllegro4r_API, "KB_ACCENT2_FLAG", INT2FIX(KB_ACCENT2_FLAG));
+  /* KB_ACCENT3_FLAG: */
+  rb_define_const(mAllegro4r_API, "KB_ACCENT3_FLAG", INT2FIX(KB_ACCENT3_FLAG));
+  /* KB_ACCENT4_FLAG: */
+  rb_define_const(mAllegro4r_API, "KB_ACCENT4_FLAG", INT2FIX(KB_ACCENT4_FLAG));
+  /* KEY_A: */
+  rb_define_const(mAllegro4r_API, "KEY_A", INT2FIX(KEY_A));
+  /* KEY_B: */
+  rb_define_const(mAllegro4r_API, "KEY_B", INT2FIX(KEY_B));
+  /* KEY_C: */
+  rb_define_const(mAllegro4r_API, "KEY_C", INT2FIX(KEY_C));
+  /* KEY_D: */
+  rb_define_const(mAllegro4r_API, "KEY_D", INT2FIX(KEY_D));
+  /* KEY_E: */
+  rb_define_const(mAllegro4r_API, "KEY_E", INT2FIX(KEY_E));
+  /* KEY_F: */
+  rb_define_const(mAllegro4r_API, "KEY_F", INT2FIX(KEY_F));
+  /* KEY_G: */
+  rb_define_const(mAllegro4r_API, "KEY_G", INT2FIX(KEY_G));
+  /* KEY_H: */
+  rb_define_const(mAllegro4r_API, "KEY_H", INT2FIX(KEY_H));
+  /* KEY_I: */
+  rb_define_const(mAllegro4r_API, "KEY_I", INT2FIX(KEY_I));
+  /* KEY_J: */
+  rb_define_const(mAllegro4r_API, "KEY_J", INT2FIX(KEY_J));
+  /* KEY_K: */
+  rb_define_const(mAllegro4r_API, "KEY_K", INT2FIX(KEY_K));
+  /* KEY_L: */
+  rb_define_const(mAllegro4r_API, "KEY_L", INT2FIX(KEY_L));
+  /* KEY_M: */
+  rb_define_const(mAllegro4r_API, "KEY_M", INT2FIX(KEY_M));
+  /* KEY_N: */
+  rb_define_const(mAllegro4r_API, "KEY_N", INT2FIX(KEY_N));
+  /* KEY_O: */
+  rb_define_const(mAllegro4r_API, "KEY_O", INT2FIX(KEY_O));
+  /* KEY_P: */
+  rb_define_const(mAllegro4r_API, "KEY_P", INT2FIX(KEY_P));
+  /* KEY_Q: */
+  rb_define_const(mAllegro4r_API, "KEY_Q", INT2FIX(KEY_Q));
+  /* KEY_R: */
+  rb_define_const(mAllegro4r_API, "KEY_R", INT2FIX(KEY_R));
+  /* KEY_S: */
+  rb_define_const(mAllegro4r_API, "KEY_S", INT2FIX(KEY_S));
+  /* KEY_T: */
+  rb_define_const(mAllegro4r_API, "KEY_T", INT2FIX(KEY_T));
+  /* KEY_U: */
+  rb_define_const(mAllegro4r_API, "KEY_U", INT2FIX(KEY_U));
+  /* KEY_V: */
+  rb_define_const(mAllegro4r_API, "KEY_V", INT2FIX(KEY_V));
+  /* KEY_W: */
+  rb_define_const(mAllegro4r_API, "KEY_W", INT2FIX(KEY_W));
+  /* KEY_X: */
+  rb_define_const(mAllegro4r_API, "KEY_X", INT2FIX(KEY_X));
+  /* KEY_Y: */
+  rb_define_const(mAllegro4r_API, "KEY_Y", INT2FIX(KEY_Y));
+  /* KEY_Z: */
+  rb_define_const(mAllegro4r_API, "KEY_Z", INT2FIX(KEY_Z));
+  /* KEY_0: */
+  rb_define_const(mAllegro4r_API, "KEY_0", INT2FIX(KEY_0));
+  /* KEY_1: */
+  rb_define_const(mAllegro4r_API, "KEY_1", INT2FIX(KEY_1));
+  /* KEY_2: */
+  rb_define_const(mAllegro4r_API, "KEY_2", INT2FIX(KEY_2));
+  /* KEY_3: */
+  rb_define_const(mAllegro4r_API, "KEY_3", INT2FIX(KEY_3));
+  /* KEY_4: */
+  rb_define_const(mAllegro4r_API, "KEY_4", INT2FIX(KEY_4));
+  /* KEY_5: */
+  rb_define_const(mAllegro4r_API, "KEY_5", INT2FIX(KEY_5));
+  /* KEY_6: */
+  rb_define_const(mAllegro4r_API, "KEY_6", INT2FIX(KEY_6));
+  /* KEY_7: */
+  rb_define_const(mAllegro4r_API, "KEY_7", INT2FIX(KEY_7));
+  /* KEY_8: */
+  rb_define_const(mAllegro4r_API, "KEY_8", INT2FIX(KEY_8));
+  /* KEY_9: */
+  rb_define_const(mAllegro4r_API, "KEY_9", INT2FIX(KEY_9));
+  /* KEY_0_PAD: */
+  rb_define_const(mAllegro4r_API, "KEY_0_PAD", INT2FIX(KEY_0_PAD));
+  /* KEY_1_PAD: */
+  rb_define_const(mAllegro4r_API, "KEY_1_PAD", INT2FIX(KEY_1_PAD));
+  /* KEY_2_PAD: */
+  rb_define_const(mAllegro4r_API, "KEY_2_PAD", INT2FIX(KEY_2_PAD));
+  /* KEY_3_PAD: */
+  rb_define_const(mAllegro4r_API, "KEY_3_PAD", INT2FIX(KEY_3_PAD));
+  /* KEY_4_PAD: */
+  rb_define_const(mAllegro4r_API, "KEY_4_PAD", INT2FIX(KEY_4_PAD));
+  /* KEY_5_PAD: */
+  rb_define_const(mAllegro4r_API, "KEY_5_PAD", INT2FIX(KEY_5_PAD));
+  /* KEY_6_PAD: */
+  rb_define_const(mAllegro4r_API, "KEY_6_PAD", INT2FIX(KEY_6_PAD));
+  /* KEY_7_PAD: */
+  rb_define_const(mAllegro4r_API, "KEY_7_PAD", INT2FIX(KEY_7_PAD));
+  /* KEY_8_PAD: */
+  rb_define_const(mAllegro4r_API, "KEY_8_PAD", INT2FIX(KEY_8_PAD));
+  /* KEY_9_PAD: */
+  rb_define_const(mAllegro4r_API, "KEY_9_PAD", INT2FIX(KEY_9_PAD));
+  /* KEY_F1: */
+  rb_define_const(mAllegro4r_API, "KEY_F1", INT2FIX(KEY_F1));
+  /* KEY_F2: */
+  rb_define_const(mAllegro4r_API, "KEY_F2", INT2FIX(KEY_F2));
+  /* KEY_F3: */
+  rb_define_const(mAllegro4r_API, "KEY_F3", INT2FIX(KEY_F3));
+  /* KEY_F4: */
+  rb_define_const(mAllegro4r_API, "KEY_F4", INT2FIX(KEY_F4));
+  /* KEY_F5: */
+  rb_define_const(mAllegro4r_API, "KEY_F5", INT2FIX(KEY_F5));
+  /* KEY_F6: */
+  rb_define_const(mAllegro4r_API, "KEY_F6", INT2FIX(KEY_F6));
+  /* KEY_F7: */
+  rb_define_const(mAllegro4r_API, "KEY_F7", INT2FIX(KEY_F7));
+  /* KEY_F8: */
+  rb_define_const(mAllegro4r_API, "KEY_F8", INT2FIX(KEY_F8));
+  /* KEY_F9: */
+  rb_define_const(mAllegro4r_API, "KEY_F9", INT2FIX(KEY_F9));
+  /* KEY_F10: */
+  rb_define_const(mAllegro4r_API, "KEY_F10", INT2FIX(KEY_F10));
+  /* KEY_F11: */
+  rb_define_const(mAllegro4r_API, "KEY_F11", INT2FIX(KEY_F11));
+  /* KEY_F12: */
+  rb_define_const(mAllegro4r_API, "KEY_F12", INT2FIX(KEY_F12));
+  /* KEY_ESC: */
+  rb_define_const(mAllegro4r_API, "KEY_ESC", INT2FIX(KEY_ESC));
+  /* KEY_TILDE: */
+  rb_define_const(mAllegro4r_API, "KEY_TILDE", INT2FIX(KEY_TILDE));
+  /* KEY_MINUS: */
+  rb_define_const(mAllegro4r_API, "KEY_MINUS", INT2FIX(KEY_MINUS));
+  /* KEY_EQUALS: */
+  rb_define_const(mAllegro4r_API, "KEY_EQUALS", INT2FIX(KEY_EQUALS));
+  /* KEY_BACKSPACE: */
+  rb_define_const(mAllegro4r_API, "KEY_BACKSPACE", INT2FIX(KEY_BACKSPACE));
+  /* KEY_TAB: */
+  rb_define_const(mAllegro4r_API, "KEY_TAB", INT2FIX(KEY_TAB));
+  /* KEY_OPENBRACE: */
+  rb_define_const(mAllegro4r_API, "KEY_OPENBRACE", INT2FIX(KEY_OPENBRACE));
+  /* KEY_CLOSEBRACE: */
+  rb_define_const(mAllegro4r_API, "KEY_CLOSEBRACE", INT2FIX(KEY_CLOSEBRACE));
+  /* KEY_ENTER: */
+  rb_define_const(mAllegro4r_API, "KEY_ENTER", INT2FIX(KEY_ENTER));
+  /* KEY_COLON: */
+  rb_define_const(mAllegro4r_API, "KEY_COLON", INT2FIX(KEY_COLON));
+  /* KEY_QUOTE: */
+  rb_define_const(mAllegro4r_API, "KEY_QUOTE", INT2FIX(KEY_QUOTE));
+  /* KEY_BACKSLASH: */
+  rb_define_const(mAllegro4r_API, "KEY_BACKSLASH", INT2FIX(KEY_BACKSLASH));
+  /* KEY_BACKSLASH2: */
+  rb_define_const(mAllegro4r_API, "KEY_BACKSLASH2", INT2FIX(KEY_BACKSLASH2));
+  /* KEY_COMMA: */
+  rb_define_const(mAllegro4r_API, "KEY_COMMA", INT2FIX(KEY_COMMA));
+  /* KEY_STOP: */
+  rb_define_const(mAllegro4r_API, "KEY_STOP", INT2FIX(KEY_STOP));
+  /* KEY_SLASH: */
+  rb_define_const(mAllegro4r_API, "KEY_SLASH", INT2FIX(KEY_SLASH));
+  /* KEY_SPACE: */
+  rb_define_const(mAllegro4r_API, "KEY_SPACE", INT2FIX(KEY_SPACE));
+  /* KEY_INSERT: */
+  rb_define_const(mAllegro4r_API, "KEY_INSERT", INT2FIX(KEY_INSERT));
+  /* KEY_DEL: */
+  rb_define_const(mAllegro4r_API, "KEY_DEL", INT2FIX(KEY_DEL));
+  /* KEY_HOME: */
+  rb_define_const(mAllegro4r_API, "KEY_HOME", INT2FIX(KEY_HOME));
+  /* KEY_END: */
+  rb_define_const(mAllegro4r_API, "KEY_END", INT2FIX(KEY_END));
+  /* KEY_PGUP: */
+  rb_define_const(mAllegro4r_API, "KEY_PGUP", INT2FIX(KEY_PGUP));
+  /* KEY_PGDN: */
+  rb_define_const(mAllegro4r_API, "KEY_PGDN", INT2FIX(KEY_PGDN));
+  /* KEY_LEFT: */
+  rb_define_const(mAllegro4r_API, "KEY_LEFT", INT2FIX(KEY_LEFT));
+  /* KEY_RIGHT: */
+  rb_define_const(mAllegro4r_API, "KEY_RIGHT", INT2FIX(KEY_RIGHT));
+  /* KEY_UP: */
+  rb_define_const(mAllegro4r_API, "KEY_UP", INT2FIX(KEY_UP));
+  /* KEY_DOWN: */
+  rb_define_const(mAllegro4r_API, "KEY_DOWN", INT2FIX(KEY_DOWN));
+  /* KEY_SLASH_PAD: */
+  rb_define_const(mAllegro4r_API, "KEY_SLASH_PAD", INT2FIX(KEY_SLASH_PAD));
+  /* KEY_ASTERISK: */
+  rb_define_const(mAllegro4r_API, "KEY_ASTERISK", INT2FIX(KEY_ASTERISK));
+  /* KEY_MINUS_PAD: */
+  rb_define_const(mAllegro4r_API, "KEY_MINUS_PAD", INT2FIX(KEY_MINUS_PAD));
+  /* KEY_PLUS_PAD: */
+  rb_define_const(mAllegro4r_API, "KEY_PLUS_PAD", INT2FIX(KEY_PLUS_PAD));
+  /* KEY_DEL_PAD: */
+  rb_define_const(mAllegro4r_API, "KEY_DEL_PAD", INT2FIX(KEY_DEL_PAD));
+  /* KEY_ENTER_PAD: */
+  rb_define_const(mAllegro4r_API, "KEY_ENTER_PAD", INT2FIX(KEY_ENTER_PAD));
+  /* KEY_PRTSCR: */
+  rb_define_const(mAllegro4r_API, "KEY_PRTSCR", INT2FIX(KEY_PRTSCR));
+  /* KEY_PAUSE: */
+  rb_define_const(mAllegro4r_API, "KEY_PAUSE", INT2FIX(KEY_PAUSE));
+  /* KEY_ABNT_C1: */
+  rb_define_const(mAllegro4r_API, "KEY_ABNT_C1", INT2FIX(KEY_ABNT_C1));
+  /* KEY_YEN: */
+  rb_define_const(mAllegro4r_API, "KEY_YEN", INT2FIX(KEY_YEN));
+  /* KEY_KANA: */
+  rb_define_const(mAllegro4r_API, "KEY_KANA", INT2FIX(KEY_KANA));
+  /* KEY_CONVERT: */
+  rb_define_const(mAllegro4r_API, "KEY_CONVERT", INT2FIX(KEY_CONVERT));
+  /* KEY_NOCONVERT: */
+  rb_define_const(mAllegro4r_API, "KEY_NOCONVERT", INT2FIX(KEY_NOCONVERT));
+  /* KEY_AT: */
+  rb_define_const(mAllegro4r_API, "KEY_AT", INT2FIX(KEY_AT));
+  /* KEY_CIRCUMFLEX: */
+  rb_define_const(mAllegro4r_API, "KEY_CIRCUMFLEX", INT2FIX(KEY_CIRCUMFLEX));
+  /* KEY_COLON2: */
+  rb_define_const(mAllegro4r_API, "KEY_COLON2", INT2FIX(KEY_COLON2));
+  /* KEY_KANJI: */
+  rb_define_const(mAllegro4r_API, "KEY_KANJI", INT2FIX(KEY_KANJI));
+  /* KEY_EQUALS_PAD: MacOS X*/
+  rb_define_const(mAllegro4r_API, "KEY_EQUALS_PAD", INT2FIX(KEY_EQUALS_PAD));
+  /* KEY_BACKQUOTE: MacOS X*/
+  rb_define_const(mAllegro4r_API, "KEY_BACKQUOTE", INT2FIX(KEY_BACKQUOTE));
+  /* KEY_SEMICOLON: MacOS X*/
+  rb_define_const(mAllegro4r_API, "KEY_SEMICOLON", INT2FIX(KEY_SEMICOLON));
+  /* KEY_COMMAND: MacOS X*/
+  rb_define_const(mAllegro4r_API, "KEY_COMMAND", INT2FIX(KEY_COMMAND));
+  /* KEY_UNKNOWN1: */
+  rb_define_const(mAllegro4r_API, "KEY_UNKNOWN1", INT2FIX(KEY_UNKNOWN1));
+  /* KEY_UNKNOWN2: */
+  rb_define_const(mAllegro4r_API, "KEY_UNKNOWN2", INT2FIX(KEY_UNKNOWN2));
+  /* KEY_UNKNOWN3: */
+  rb_define_const(mAllegro4r_API, "KEY_UNKNOWN3", INT2FIX(KEY_UNKNOWN3));
+  /* KEY_UNKNOWN4: */
+  rb_define_const(mAllegro4r_API, "KEY_UNKNOWN4", INT2FIX(KEY_UNKNOWN4));
+  /* KEY_UNKNOWN5: */
+  rb_define_const(mAllegro4r_API, "KEY_UNKNOWN5", INT2FIX(KEY_UNKNOWN5));
+  /* KEY_UNKNOWN6: */
+  rb_define_const(mAllegro4r_API, "KEY_UNKNOWN6", INT2FIX(KEY_UNKNOWN6));
+  /* KEY_UNKNOWN7: */
+  rb_define_const(mAllegro4r_API, "KEY_UNKNOWN7", INT2FIX(KEY_UNKNOWN7));
+  /* KEY_UNKNOWN8: */
+  rb_define_const(mAllegro4r_API, "KEY_UNKNOWN8", INT2FIX(KEY_UNKNOWN8));
+  /* KEY_MODIFIERS: */
+  rb_define_const(mAllegro4r_API, "KEY_MODIFIERS", INT2FIX(KEY_MODIFIERS));
+  /* KEY_LSHIFT: */
+  rb_define_const(mAllegro4r_API, "KEY_LSHIFT", INT2FIX(KEY_LSHIFT));
+  /* KEY_RSHIFT: */
+  rb_define_const(mAllegro4r_API, "KEY_RSHIFT", INT2FIX(KEY_RSHIFT));
+  /* KEY_LCONTROL: */
+  rb_define_const(mAllegro4r_API, "KEY_LCONTROL", INT2FIX(KEY_LCONTROL));
+  /* KEY_RCONTROL: */
+  rb_define_const(mAllegro4r_API, "KEY_RCONTROL", INT2FIX(KEY_RCONTROL));
+  /* KEY_ALT: */
+  rb_define_const(mAllegro4r_API, "KEY_ALT", INT2FIX(KEY_ALT));
+  /* KEY_ALTGR: */
+  rb_define_const(mAllegro4r_API, "KEY_ALTGR", INT2FIX(KEY_ALTGR));
+  /* KEY_LWIN: */
+  rb_define_const(mAllegro4r_API, "KEY_LWIN", INT2FIX(KEY_LWIN));
+  /* KEY_RWIN: */
+  rb_define_const(mAllegro4r_API, "KEY_RWIN", INT2FIX(KEY_RWIN));
+  /* KEY_MENU: */
+  rb_define_const(mAllegro4r_API, "KEY_MENU", INT2FIX(KEY_MENU));
+  /* KEY_SCRLOCK: */
+  rb_define_const(mAllegro4r_API, "KEY_SCRLOCK", INT2FIX(KEY_SCRLOCK));
+  /* KEY_NUMLOCK: */
+  rb_define_const(mAllegro4r_API, "KEY_NUMLOCK", INT2FIX(KEY_NUMLOCK));
+  /* KEY_CAPSLOCK: */
+  rb_define_const(mAllegro4r_API, "KEY_CAPSLOCK", INT2FIX(KEY_CAPSLOCK));
+  /* KEY_MAX: */
+  rb_define_const(mAllegro4r_API, "KEY_MAX", INT2FIX(KEY_MAX));
+
+  /* JOY_TYPE_AUTODETECT: */
+  rb_define_const(mAllegro4r_API, "JOY_TYPE_AUTODETECT", INT2FIX(JOY_TYPE_AUTODETECT));
+  /* JOY_TYPE_NONE: */
+  rb_define_const(mAllegro4r_API, "JOY_TYPE_NONE", INT2FIX(JOY_TYPE_NONE));
+
+  /* JOYFLAG_DIGITAL: This control is currently providing digital input. */
+  rb_define_const(mAllegro4r_API, "JOYFLAG_DIGITAL", INT2FIX(JOYFLAG_DIGITAL));
+  /* JOYFLAG_ANALOGUE: This control is currently providing analogue input. */
+  rb_define_const(mAllegro4r_API, "JOYFLAG_ANALOGUE", INT2FIX(JOYFLAG_ANALOGUE));
+  /*
+   * JOYFLAG_CALIB_DIGITAL: This control will be capable of providing digital
+   * input once it has been calibrated, but is not doing this at the moment.
+   */
+  rb_define_const(mAllegro4r_API, "JOYFLAG_CALIB_DIGITAL", INT2FIX(JOYFLAG_CALIB_DIGITAL));
+  /*
+   * JOYFLAG_CALIB_ANALOGUE: This control will be capable of providing analogue
+   * input once it has been calibrated, but is not doing this at the moment.
+   */
+  rb_define_const(mAllegro4r_API, "JOYFLAG_CALIB_ANALOGUE", INT2FIX(JOYFLAG_CALIB_ANALOGUE));
+  /*
+   * JOYFLAG_CALIBRATE: Indicates that this control needs to be calibrated. Many
+   * devices require multiple calibration steps, so you should call the
+   * calibrate_joystick function from a loop until this flag is cleared.
+   */
+  rb_define_const(mAllegro4r_API, "JOYFLAG_CALIBRATE", INT2FIX(JOYFLAG_CALIBRATE));
+  /*
+   * JOYFLAG_SIGNED: Indicates that the analogue axis position is in signed
+   * format, ranging from -128 to 128. This is the case for all 2d directional
+   * controls.
+   */
+  rb_define_const(mAllegro4r_API, "JOYFLAG_SIGNED", INT2FIX(JOYFLAG_SIGNED));
+  /*
+   * JOYFLAG_UNSIGNED: Indicates that the analogue axis position is in unsigned
+   * format, ranging from 0 to 255. This is the case for all 1d throttle
+   * controls.
+   */
+  rb_define_const(mAllegro4r_API, "JOYFLAG_UNSIGNED", INT2FIX(JOYFLAG_UNSIGNED));
+
+  /* DIGI_AUTODETECT: Let Allegro pick a digital sound driver */
+  rb_define_const(mAllegro4r_API, "DIGI_AUTODETECT", INT2FIX(DIGI_AUTODETECT));
+  /* DIGI_NONE: No digital sound */
+  rb_define_const(mAllegro4r_API, "DIGI_NONE", INT2FIX(DIGI_NONE));
+
+  /* MIDI_AUTODETECT: Let Allegro pick a MIDI sound driver */
+  rb_define_const(mAllegro4r_API, "MIDI_AUTODETECT", INT2FIX(MIDI_AUTODETECT));
+  /* MIDI_NONE: No MIDI sound */
+  rb_define_const(mAllegro4r_API, "MIDI_NONE", INT2FIX(MIDI_NONE));
+}
+
+// needed if Allegro is built as a shared library
+int main()
+{
+  return 0;
+}
+END_OF_MAIN()