/* ========================================================================= */
void InitProgramInfo(char *argv0,
- char *userdata_directory, char *program_title,
- char *window_title, char *icon_title,
+ char *userdata_subdir, char *userdata_subdir_unix,
+ char *program_title, char *window_title, char *icon_title,
char *x11_icon_filename, char *x11_iconmask_filename,
- char *msdos_cursor_filename,
+ char *sdl_icon_filename, char *msdos_cursor_filename,
char *cookie_prefix, char *filename_prefix,
int program_version)
{
program.command_basepath = getBasePath(argv0);
program.command_basename = getBaseName(argv0);
- program.userdata_directory = userdata_directory;
+ program.userdata_subdir = userdata_subdir;
+ program.userdata_subdir_unix = userdata_subdir_unix;
+ program.userdata_path = getUserGameDataDir();
+
program.program_title = program_title;
program.window_title = window_title;
program.icon_title = icon_title;
+
program.x11_icon_filename = x11_icon_filename;
program.x11_iconmask_filename = x11_iconmask_filename;
+ program.sdl_icon_filename = sdl_icon_filename;
program.msdos_cursor_filename = msdos_cursor_filename;
program.cookie_prefix = cookie_prefix;
program.version_major = VERSION_MAJOR(program_version);
program.version_minor = VERSION_MINOR(program_version);
program.version_patch = VERSION_PATCH(program_version);
+
+ program.error_filename = getErrorFilename(ERROR_BASENAME);
+ program.error_file = stderr;
}
void InitExitFunction(void (*exit_function)(int))
{
#if defined(PLATFORM_MSDOS)
_fmode = O_BINARY;
- initErrorFile();
+#endif
+
+#if defined(PLATFORM_MACOSX)
+ updateUserGameDataDir();
+#endif
+
+#if !defined(PLATFORM_UNIX) || defined(PLATFORM_MACOSX)
+ openErrorFile();
#endif
#if defined(TARGET_SDL)
void ClosePlatformDependentStuff(void)
{
+#if defined(PLATFORM_WIN32) || defined(PLATFORM_MSDOS)
+ closeErrorFile();
+#endif
+
#if defined(PLATFORM_MSDOS)
dumpErrorFile();
#endif
#endif
}
-inline void InitVideoDisplay(void)
+void InitVideoDisplay(void)
{
#if defined(TARGET_SDL)
SDLInitVideoDisplay();
#endif
}
-inline void CloseVideoDisplay(void)
+void CloseVideoDisplay(void)
{
KeyboardAutoRepeatOn();
#endif
}
-inline void InitVideoBuffer(DrawBuffer **backbuffer, DrawWindow **window,
- int width, int height, int depth,
- boolean fullscreen)
+void InitVideoBuffer(DrawBuffer **backbuffer, DrawWindow **window,
+ int width, int height, int depth, boolean fullscreen)
{
video.width = width;
video.height = height;
video.depth = GetRealDepth(depth);
+
video.fullscreen_available = FULLSCREEN_STATUS;
video.fullscreen_enabled = FALSE;
+ video.fullscreen_modes = NULL;
+ video.fullscreen_mode_current = NULL;
#if defined(TARGET_SDL)
SDLInitVideoBuffer(backbuffer, window, fullscreen);
#endif
}
-inline Bitmap *CreateBitmapStruct(void)
+Bitmap *CreateBitmapStruct(void)
{
#if defined(TARGET_SDL)
return checked_calloc(sizeof(struct SDLSurfaceInfo));
#endif
}
-inline Bitmap *CreateBitmap(int width, int height, int depth)
+Bitmap *CreateBitmap(int width, int height, int depth)
{
Bitmap *new_bitmap = CreateBitmapStruct();
int real_depth = GetRealDepth(depth);
*dst_bitmap = *src_bitmap;
}
-inline void FreeBitmap(Bitmap *bitmap)
+void FreeBitmap(Bitmap *bitmap)
{
if (bitmap == NULL)
return;
free(bitmap);
}
-inline void CloseWindow(DrawWindow *window)
+void CloseWindow(DrawWindow *window)
{
#if defined(TARGET_X11)
if (window->drawable)
#endif
}
-static inline boolean CheckDrawingArea(int x, int y, int width, int height,
+inline static boolean CheckDrawingArea(int x, int y, int width, int height,
int draw_mask)
{
if (draw_mask == REDRAW_NONE)
return FALSE;
}
-inline boolean DrawingDeactivated(int x, int y, int width, int height)
+boolean DrawingDeactivated(int x, int y, int width, int height)
{
return CheckDrawingArea(x, y, width, height, gfx.draw_deactivation_mask);
}
-inline boolean DrawingOnBackground(int x, int y)
+boolean DrawingOnBackground(int x, int y)
{
return (CheckDrawingArea(x, y, 1, 1, gfx.background_bitmap_mask) &&
CheckDrawingArea(x, y, 1, 1, gfx.draw_background_mask));
}
-inline void BlitBitmap(Bitmap *src_bitmap, Bitmap *dst_bitmap,
- int src_x, int src_y, int width, int height,
- int dst_x, int dst_y)
+void BlitBitmap(Bitmap *src_bitmap, Bitmap *dst_bitmap,
+ int src_x, int src_y, int width, int height,
+ int dst_x, int dst_y)
{
if (DrawingDeactivated(dst_x, dst_y, width, height))
return;
dst_x, dst_y, BLIT_OPAQUE);
}
-inline void FillRectangle(Bitmap *bitmap, int x, int y, int width, int height,
- Pixel color)
+void FadeRectangle(Bitmap *bitmap_cross, int x, int y, int width, int height,
+ int fade_mode, int fade_delay, int post_delay)
+{
+#if defined(TARGET_SDL)
+ SDLFadeRectangle(bitmap_cross, x, y, width, height,
+ fade_mode, fade_delay, post_delay);
+#else
+ X11FadeRectangle(bitmap_cross, x, y, width, height,
+ fade_mode, fade_delay, post_delay);
+#endif
+}
+
+void FillRectangle(Bitmap *bitmap, int x, int y, int width, int height,
+ Pixel color)
{
if (DrawingDeactivated(x, y, width, height))
return;
sysFillRectangle(bitmap, x, y, width, height, color);
}
-inline void ClearRectangle(Bitmap *bitmap, int x, int y, int width, int height)
+void ClearRectangle(Bitmap *bitmap, int x, int y, int width, int height)
{
FillRectangle(bitmap, x, y, width, height, BLACK_PIXEL);
}
-inline void ClearRectangleOnBackground(Bitmap *bitmap, int x, int y,
- int width, int height)
+void ClearRectangleOnBackground(Bitmap *bitmap, int x, int y,
+ int width, int height)
{
if (DrawingOnBackground(x, y))
BlitBitmap(gfx.background_bitmap, bitmap, x, y, width, height, x, y);
ClearRectangle(bitmap, x, y, width, height);
}
-inline void SetClipMask(Bitmap *bitmap, GC clip_gc, Pixmap clip_pixmap)
+void SetClipMask(Bitmap *bitmap, GC clip_gc, Pixmap clip_pixmap)
{
#if defined(TARGET_X11)
if (clip_gc)
#endif
}
-inline void SetClipOrigin(Bitmap *bitmap, GC clip_gc, int clip_x, int clip_y)
+void SetClipOrigin(Bitmap *bitmap, GC clip_gc, int clip_x, int clip_y)
{
#if defined(TARGET_X11)
if (clip_gc)
#endif
}
-inline void BlitBitmapMasked(Bitmap *src_bitmap, Bitmap *dst_bitmap,
- int src_x, int src_y,
- int width, int height,
- int dst_x, int dst_y)
+void BlitBitmapMasked(Bitmap *src_bitmap, Bitmap *dst_bitmap,
+ int src_x, int src_y, int width, int height,
+ int dst_x, int dst_y)
{
if (DrawingDeactivated(dst_x, dst_y, width, height))
return;
dst_x, dst_y, BLIT_MASKED);
}
-inline void BlitBitmapOnBackground(Bitmap *src_bitmap, Bitmap *dst_bitmap,
- int src_x, int src_y,
- int width, int height,
- int dst_x, int dst_y)
+void BlitBitmapOnBackground(Bitmap *src_bitmap, Bitmap *dst_bitmap,
+ int src_x, int src_y, int width, int height,
+ int dst_x, int dst_y)
{
if (DrawingOnBackground(dst_x, dst_y))
{
dst_x, dst_y);
}
-inline void DrawSimpleBlackLine(Bitmap *bitmap, int from_x, int from_y,
- int to_x, int to_y)
+void DrawSimpleBlackLine(Bitmap *bitmap, int from_x, int from_y,
+ int to_x, int to_y)
{
#if defined(TARGET_SDL)
SDLDrawSimpleLine(bitmap, from_x, from_y, to_x, to_y, BLACK_PIXEL);
#endif
}
-inline void DrawSimpleWhiteLine(Bitmap *bitmap, int from_x, int from_y,
- int to_x, int to_y)
+void DrawSimpleWhiteLine(Bitmap *bitmap, int from_x, int from_y,
+ int to_x, int to_y)
{
#if defined(TARGET_SDL)
SDLDrawSimpleLine(bitmap, from_x, from_y, to_x, to_y, WHITE_PIXEL);
}
#if !defined(TARGET_X11_NATIVE)
-inline void DrawLine(Bitmap *bitmap, int from_x, int from_y,
- int to_x, int to_y, Pixel pixel, int line_width)
+void DrawLine(Bitmap *bitmap, int from_x, int from_y,
+ int to_x, int to_y, Pixel pixel, int line_width)
{
int x, y;
}
#endif
-inline void DrawLines(Bitmap *bitmap, struct XY *points, int num_points,
- Pixel pixel)
+void DrawLines(Bitmap *bitmap, struct XY *points, int num_points, Pixel pixel)
{
#if !defined(TARGET_X11_NATIVE)
int line_width = 4;
#endif
}
-inline Pixel GetPixel(Bitmap *bitmap, int x, int y)
+Pixel GetPixel(Bitmap *bitmap, int x, int y)
{
if (x < 0 || x >= bitmap->width ||
y < 0 || y >= bitmap->height)
#endif
}
-inline Pixel GetPixelFromRGB(Bitmap *bitmap, unsigned int color_r,
- unsigned int color_g, unsigned int color_b)
+Pixel GetPixelFromRGB(Bitmap *bitmap, unsigned int color_r,
+ unsigned int color_g, unsigned int color_b)
{
#if defined(TARGET_SDL)
return SDL_MapRGB(bitmap->surface->format, color_r, color_g, color_b);
#endif
}
-inline Pixel GetPixelFromRGBcompact(Bitmap *bitmap, unsigned int color)
+Pixel GetPixelFromRGBcompact(Bitmap *bitmap, unsigned int color)
{
unsigned int color_r = (color >> 16) & 0xff;
unsigned int color_g = (color >> 8) & 0xff;
}
/* execute all pending screen drawing operations */
-inline void FlushDisplay(void)
+void FlushDisplay(void)
{
#ifndef TARGET_SDL
XFlush(display);
}
/* execute and wait for all pending screen drawing operations */
-inline void SyncDisplay(void)
+void SyncDisplay(void)
{
#ifndef TARGET_SDL
XSync(display, FALSE);
#endif
}
-inline void KeyboardAutoRepeatOn(void)
+void KeyboardAutoRepeatOn(void)
{
#if defined(TARGET_SDL)
SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY / 2,
#endif
}
-inline void KeyboardAutoRepeatOff(void)
+void KeyboardAutoRepeatOff(void)
{
#if defined(TARGET_SDL)
SDL_EnableKeyRepeat(0, SDL_DEFAULT_REPEAT_INTERVAL);
#endif
}
-inline boolean PointerInWindow(DrawWindow *window)
+boolean PointerInWindow(DrawWindow *window)
{
#if defined(TARGET_SDL)
return TRUE;
#endif
}
-inline boolean SetVideoMode(boolean fullscreen)
+boolean SetVideoMode(boolean fullscreen)
{
#if defined(TARGET_SDL)
return SDLSetVideoMode(&backbuffer, fullscreen);
#endif
}
-inline boolean ChangeVideoModeIfNeeded(boolean fullscreen)
+boolean ChangeVideoModeIfNeeded(boolean fullscreen)
{
#if defined(TARGET_SDL)
if ((fullscreen && !video.fullscreen_enabled && video.fullscreen_available)||
boolean create_small_bitmaps)
{
Bitmap swap_bitmap;
- Bitmap *new_bitmap, *tmp_bitmap_1, *tmp_bitmap_2, *tmp_bitmap_8;
- int width_1, height_1, width_2, height_2, width_8, height_8;
+ Bitmap *new_bitmap, *tmp_bitmap_1, *tmp_bitmap_2, *tmp_bitmap_4,*tmp_bitmap_8;
+ int width_1, height_1, width_2, height_2, width_4, height_4, width_8,height_8;
int new_width, new_height;
/* calculate new image dimensions for normal sized image */
else
tmp_bitmap_1 = old_bitmap;
+ /* this is only needed to make compilers happy */
+ tmp_bitmap_2 = tmp_bitmap_4 = tmp_bitmap_8 = NULL;
+
if (create_small_bitmaps)
{
/* calculate new image dimensions for small images */
width_2 = width_1 / 2;
height_2 = height_1 / 2;
+ width_4 = width_1 / 4;
+ height_4 = height_1 / 4;
width_8 = width_1 / 8;
height_8 = height_1 / 8;
else
tmp_bitmap_2 = old_bitmap;
+ /* get image with 1/4 of normal size (for use in the level editor) */
+ if (zoom_factor != 4)
+ tmp_bitmap_4 = ZoomBitmap(tmp_bitmap_2, width_2 / 2, height_2 / 2);
+ else
+ tmp_bitmap_4 = old_bitmap;
+
/* get image with 1/8 of normal size (for use on the preview screen) */
if (zoom_factor != 8)
- tmp_bitmap_8 = ZoomBitmap(tmp_bitmap_1, width_1 / 8, height_1 / 8);
+ tmp_bitmap_8 = ZoomBitmap(tmp_bitmap_4, width_4 / 2, height_4 / 2);
else
tmp_bitmap_8 = old_bitmap;
}
BlitBitmap(tmp_bitmap_1, new_bitmap, 0, 0, width_1, height_1, 0, 0);
BlitBitmap(tmp_bitmap_2, new_bitmap, 0, 0, width_1 / 2, height_1 / 2,
0, height_1);
+ BlitBitmap(tmp_bitmap_4, new_bitmap, 0, 0, width_1 / 4, height_1 / 4,
+ width_1 / 2, height_1);
BlitBitmap(tmp_bitmap_8, new_bitmap, 0, 0, width_1 / 8, height_1 / 8,
3 * width_1 / 4, height_1);
}
if (zoom_factor != 2)
FreeBitmap(tmp_bitmap_2);
+ if (zoom_factor != 4)
+ FreeBitmap(tmp_bitmap_4);
+
if (zoom_factor != 8)
FreeBitmap(tmp_bitmap_8);
}
- /* replace image with extended image (containing normal, 1/2 and 1/8 size) */
+ /* replace image with extended image (containing 1/1, 1/2, 1/4, 1/8 size) */
#if defined(TARGET_SDL)
swap_bitmap.surface = old_bitmap->surface;
old_bitmap->surface = new_bitmap->surface;
/* audio functions */
/* ========================================================================= */
-inline void OpenAudio(void)
+void OpenAudio(void)
{
/* always start with reliable default values */
audio.sound_available = FALSE;
#endif
}
-inline void CloseAudio(void)
+void CloseAudio(void)
{
#if defined(TARGET_SDL)
SDLCloseAudio();
audio.sound_enabled = FALSE;
}
-inline void SetAudioMode(boolean enabled)
+void SetAudioMode(boolean enabled)
{
if (!audio.sound_available)
return;
/* event functions */
/* ========================================================================= */
-inline void InitEventFilter(EventFilter filter_function)
+void InitEventFilter(EventFilter filter_function)
{
#if defined(TARGET_SDL)
/* set event filter to filter out certain events */
#endif
}
-inline boolean PendingEvent(void)
+boolean PendingEvent(void)
{
#if defined(TARGET_SDL)
return (SDL_PollEvent(NULL) ? TRUE : FALSE);
#endif
}
-inline void NextEvent(Event *event)
+void NextEvent(Event *event)
{
#if defined(TARGET_SDL)
SDLNextEvent(event);
#endif
}
-inline void PeekEvent(Event *event)
+void PeekEvent(Event *event)
{
#if defined(TARGET_SDL)
SDL_PeepEvents(event, 1, SDL_PEEKEVENT, SDL_ALLEVENTS);
#endif
}
-inline Key GetEventKey(KeyEvent *event, boolean with_modifiers)
+Key GetEventKey(KeyEvent *event, boolean with_modifiers)
{
#if defined(TARGET_SDL)
#endif
}
-inline KeyMod HandleKeyModState(Key key, int key_status)
+KeyMod HandleKeyModState(Key key, int key_status)
{
static KeyMod current_modifiers = KMOD_None;
-#if !defined(TARGET_SDL)
if (key != KSYM_UNDEFINED) /* new key => check for modifier key change */
{
KeyMod new_modifier = KMOD_None;
else
current_modifiers &= ~new_modifier;
}
-#endif
return current_modifiers;
}
-inline KeyMod GetKeyModState()
+KeyMod GetKeyModState()
{
#if defined(TARGET_SDL)
return (KeyMod)SDL_GetModState();
#endif
}
-inline boolean CheckCloseWindowEvent(ClientMessageEvent *event)
+KeyMod GetKeyModStateFromEvents()
+{
+ /* always use key modifier state as tracked from key events (this is needed
+ if the modifier key event was injected into the event queue, but the key
+ was not really pressed on keyboard -- SDL_GetModState() seems to directly
+ query the keys as held pressed on the keyboard) -- this case is currently
+ only used to filter out clipboard insert events from "True X-Mouse" tool */
+
+ return HandleKeyModState(KSYM_UNDEFINED, 0);
+}
+
+boolean CheckCloseWindowEvent(ClientMessageEvent *event)
{
if (event->type != EVENT_CLIENTMESSAGE)
return FALSE;
/* joystick functions */
/* ========================================================================= */
-inline void InitJoysticks()
+void InitJoysticks()
{
int i;
#endif
}
-inline boolean ReadJoystick(int nr, int *x, int *y, boolean *b1, boolean *b2)
+boolean ReadJoystick(int nr, int *x, int *y, boolean *b1, boolean *b2)
{
#if defined(TARGET_SDL)
return SDLReadJoystick(nr, x, y, b1, b2);
projects / rocksndiamonds.git / blobdiff