diff options
26 files changed, 1700 insertions, 41 deletions
diff --git a/distrib/sdl-1.2.15/Makefile b/distrib/sdl-1.2.15/Makefile new file mode 100644 index 0000000..477677b --- /dev/null +++ b/distrib/sdl-1.2.15/Makefile @@ -0,0 +1,71 @@ +# Copyright (C) 2012 The Android Open Source Project +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +# this is a set of definitions that allow the usage of Makefile.android +# even if we're not using the Android build system. +# + +OBJS_DIR := objs +CONFIG_MAKE := $(OBJS_DIR)/config.make +CONFIG_H := $(OBJS_DIR)/config-host.h + +ifeq ($(wildcard $(CONFIG_MAKE)),) + $(error "The configuration file '$(CONFIG_MAKE)' doesnt' exist, please run the "android-configure.sh" script) +endif + +include $(CONFIG_MAKE) + +ifeq ($(strip $(BUILD_SYSTEM)),) + $(error "The BUILD_SYSTEM variable was not defined by your configuration sub-makefile. Aborting") +endif + +include $(BUILD_SYSTEM)/definitions.make + +VPATH := $(OBJS_DIR) +VPATH += :$(SRC_PATH)/include +VPATH += :$(SRC_PATH) + +.PHONY: all libraries executables clean clean-config clean-objs-dir \ + clean-executables clean-libraries + +CLEAR_VARS := $(BUILD_SYSTEM)/clear_vars.make +BUILD_HOST_EXECUTABLE := $(BUILD_SYSTEM)/host_executable.make +BUILD_HOST_STATIC_LIBRARY := $(BUILD_SYSTEM)/host_static_library.make + +DEPENDENCY_DIRS := + +all: libraries executables +EXECUTABLES := +LIBRARIES := + +clean: clean-intermediates + +distclean: clean clean-config + +# let's roll +include Makefile.android + +libraries: $(LIBRARIES) +executables: $(EXECUTABLES) + +clean-intermediates: + rm -rf $(OBJS_DIR)/intermediates $(EXECUTABLES) $(LIBRARIES) + +clean-config: + rm -f $(CONFIG_MAKE) $(CONFIG_H) + +# include dependency information +DEPENDENCY_DIRS := $(sort $(DEPENDENCY_DIRS)) +-include $(wildcard $(DEPENDENCY_DIRS:%=%/*.d)) diff --git a/distrib/sdl-1.2.15/Makefile.android b/distrib/sdl-1.2.15/Makefile.android new file mode 100644 index 0000000..2dfa7dd --- /dev/null +++ b/distrib/sdl-1.2.15/Makefile.android @@ -0,0 +1,93 @@ +LOCAL_PATH:= $(call my-dir) + +SDL_DIR := $(LOCAL_PATH) +include $(SDL_DIR)/sources.make + +CONFIG_DIRS := \ + $(LOCAL_PATH)/objs \ + $(LOCAL_PATH)/include \ + $(LOCAL_PATH) \ + +CONFIG_INCLUDES := $(CONFIG_DIRS:%=-I%) + +MY_CC := $(CC) +MY_LD := $(LD) +MY_CFLAGS := $(CFLAGS) $(CONFIG_INCLUDES) +MY_LDFLAGS := $(LDFLAGS) + +include $(CLEAR_VARS) + +LOCAL_NO_DEFAULT_COMPILER_FLAGS := true +LOCAL_CC := $(MY_CC) +LOCAL_CFLAGS := $(MY_CFLAGS) $(LOCAL_CFLAGS) +LOCAL_LDFLAGS := $(MY_LDFLAGS) $(LOCAL_LDFLAGS) + +LOCAL_MODULE := libSDL + +LOCAL_SRC_FILES := $(SDL_SOURCES) + +include $(BUILD_HOST_STATIC_LIBRARY) + +## Build libSDLmain +## + +include $(CLEAR_VARS) + +LOCAL_NO_DEFAULT_COMPILER_FLAGS := true +LOCAL_CC := $(MY_CC) +LOCAL_CFLAGS := $(MY_CFLAGS) $(LOCAL_CFLAGS) +LOCAL_LDFLAGS := $(MY_LDFLAGS) $(LOCAL_LDFLAGS) + +LOCAL_MODULE := libSDLmain + +LOCAL_SRC_FILES := $(SDLMAIN_SOURCES) + +include $(BUILD_HOST_STATIC_LIBRARY) + +# handle installation of generated files +# + +SDL_HEADERS := \ + SDL.h \ + SDL_active.h \ + SDL_audio.h \ + SDL_byteorder.h \ + SDL_cdrom.h \ + SDL_copying.h \ + SDL_cpuinfo.h \ + SDL_endian.h \ + SDL_error.h \ + SDL_events.h \ + SDL_getenv.h \ + SDL_joystick.h \ + SDL_keyboard.h \ + SDL_keysym.h \ + SDL_loadso.h \ + SDL_main.h \ + SDL_mouse.h \ + SDL_mutex.h \ + SDL_name.h \ + SDL_opengl.h \ + SDL_platform.h \ + SDL_quit.h \ + SDL_rwops.h \ + SDL_stdinc.h \ + SDL_syswm.h \ + SDL_thread.h \ + SDL_timer.h \ + SDL_types.h \ + SDL_version.h \ + SDL_video.h \ + begin_code.h \ + close_code.h \ + + +$(foreach target,$(INSTALL_TARGETS),\ + $(eval $(call install-target,objs/sdl-config,$(target)/bin/sdl-config)) \ + $(eval $(call install-target,objs/SDL_config.h,$(target)/include/SDL/SDL_config.h)) \ + $(eval $(call install-target,objs/libs/libSDL.a,$(target)/libs/libSDL.a)) \ + $(eval $(call install-target,objs/libs/libSDLmain.a,$(target)/libs/libSDLmain.a)) \ + $(foreach header,$(SDL_HEADERS), \ + $(eval $(call install-target,include/$(header),$(target)/include/SDL/$(header))) \ + ) \ +) diff --git a/distrib/sdl-1.2.15/README.ANDROID b/distrib/sdl-1.2.15/README.ANDROID new file mode 100644 index 0000000..cc4fee2 --- /dev/null +++ b/distrib/sdl-1.2.15/README.ANDROID @@ -0,0 +1,9 @@ +This is a modified version of SDL 1.2.15 that is used by the Android QEMU +emulator. See the git history for modifications relative to upstream. + +To build it as a static library on Linux, OS X and Windows: + +./android-configure.sh [--prefix=<path>] +make -j2 +make install + diff --git a/distrib/sdl-1.2.15/android-configure.sh b/distrib/sdl-1.2.15/android-configure.sh new file mode 100755 index 0000000..94ef732 --- /dev/null +++ b/distrib/sdl-1.2.15/android-configure.sh @@ -0,0 +1,553 @@ +#/bin/sh +# +# this script is used to rebuild SDL from sources in the current +# directory. It depends on the Android emulator build scripts +# that should normally be located in ../emulator/android/build +# but you can also use ANDROID_QEMU_PATH in your environment +# to point to the top of the Android emulator sources +# +# + +# first, let's see which system we're running this on +cd `dirname $0` + +# try to find the Android build directory automatically +if [ -z "$ANDROID_QEMU_PATH" ] ; then + if [ -f ../../android/build/common.sh ] ; then + ANDROID_QEMU_PATH=../.. + else + echo "You must define ANDROID_QEMU_PATH in your environment to point" + echo "to the directory containing the Android emulator's sources." + exit 1 + fi +fi + +if [ ! -d $ANDROID_QEMU_PATH ] ; then + echo "Your ANDROID_QEMU_PATH does not point to a valid directory." + exit 1 +fi + +if [ ! -f $ANDROID_QEMU_PATH/android/build/common.sh ] ; then + echo "Your ANDROID_QEMU_PATH does not point to a directory that" + echo "contains the Android emulator build scripts." + exit 1 +fi + +# source common functions definitions +. $ANDROID_QEMU_PATH/android/build/common.sh + +# Parse options +OPTION_TRY_64=no +OPTION_HELP=no +OPTION_TARGETS= +OPTION_FORCE_AUTODETECT=no +OPTION_NO_TIGER=no + +if [ -z "$CC" ] ; then + CC=gcc +fi + +for opt do + optarg=`expr "x$opt" : 'x[^=]*=\(.*\)'` + case "$opt" in + --help|-h|-\?) OPTION_HELP=yes + ;; + --verbose) + if [ "$VERBOSE" = "yes" ] ; then + VERBOSE2=yes + else + VERBOSE=yes + fi + ;; + --cc=*) CC="$optarg" ; HOSTCC=$CC + ;; + --try-64) OPTION_TRY_64=yes + ;; + --prefix=*) OPTION_TARGETS="$OPTION_TARGETS $optarg" + ;; + --force-autodetect) OPTION_FORCE_AUTODETECT=yes + ;; + --no-tiger) OPTION_NO_TIGER=yes + ;; + *) + echo "unknown option '$opt', use --help" + exit 1 + esac +done + +# Print the help message +# +if [ "$OPTION_HELP" = "yes" ] ; then + cat << EOF + +Usage: rebuild.sh [options] +Options: [defaults in brackets after descriptions] +EOF + echo "Standard options:" + echo " --help print this message" + echo " --cc=PATH specify C compiler [$CC]" + echo " --try-64 try to build a 64-bit executable (may crash)" + echo " --verbose verbose configuration" + echo " --force-autodetect force feature auto-detection" + echo " --no-tiger do not generate Tiger-compatible binaries (OS X only)" + echo "" + exit 1 +fi + +# we only support generating 32-bit binaris on 64-bit systems. +# And we may need to add a -Wa,--32 to CFLAGS to let the assembler +# generate 32-bit binaries on Linux x86_64. +# +if [ "$OPTION_TRY_64" != "yes" ] ; then + force_32bit_binaries +fi + +# default target +if [ -z "$OPTION_TARGETS" ] ; then + OPTION_TARGETS=out/$OS +fi + +# we can build SDL with Cygwin, so enable it +enable_cygwin + +setup_toolchain + +### +### Special compiler and linker flags +### + +case "$OS" in + linux-*) + BUILD_CFLAGS="-D_GNU_SOURCE=1 -fvisibility=hidden -DXTHREADS -D_REENTRANT" + # prevent -fstack-protector or the generated binaries will not link + BUILD_CFLAGS="$BUILD_CFLAGS -fno-stack-protector" + ;; + darwin-*) + BUILD_CFLAGS="-D_GNU_SOURCE=1 -fvisibility=hidden -DTARGET_API_MAC_CARBON -DTARGET_API_MAC_OSX -D_THREAD_SAFE -force_cpusubtype_ALL -fpascal-strings" + # detect the 10.4 SDK and use it automatically + TIGER_SDK=/Developer/SDKs/MacOSX10.4u.sdk + if [ ! -d $TIGER_SDK -a $OPTION_NO_TIGER = no ] ; then + echo "Please install the 10.4 SDK at $TIGER_SDK to generate Tiger-compatible binaries." + echo "If you don't want compatibility, use --no-tiger option instead." + exit 1 + fi + if [ -d $TIGER_SDK ] ; then + TIGER_OPTS="-isysroot $TIGER_SDK -mmacosx-version-min=10.4" + BUILD_CFLAGS="$BUILD_CFLAGS $TIGER_OPTS" + BUILD_LDFLAGS="$BUILD_LDFLAGS $TIGER_OPTS -Wl,-syslibroot,$(TIGER_SDK)" + echo "Using OS X 10.4 SDK to generate Tiger-compatible binaries." + else + echo "Warning: the generated binaries will not be compatible with Tiger." + fi + ;; + windows) + BUILD_CFLAGS="-D_GNU_SOURCE=1" + ;; + *) + BUILD_CFLAGS= +esac + +# BUILD_CFLAGS are used to build SDL, but SDL_CFLAGS are used +# when clients want to use its facilities +# +case "$HOST_OS" in + linux) + SDL_CFLAGS="-D_GNU_SOURCE=1 -D_REENTRANT" + SDL_STATIC_LIBS="-lm -ldl -lpthread -lrt" + ;; + darwin) + SDL_CFLAGS="-D_GNU_SOURCE=1 -D_THREAD_SAFE" + SDL_STATIC_LIBS="-Wl,-framework,OpenGL -Wl,-framework,Cocoa -Wl,-framework,QuickTime -Wl,-framework,ApplicationServices -Wl,-framework,Carbon -Wl,-framework,IOKit" + ;; + windows) + SDL_CFLAGS="-D_GNU_SOURCE=1 -Dmain=SDL_main" + SDL_STATIC_LIBS="-luser32 -lgdi32 -lwinmm" + ;; + *) + SDL_CFLAGS= + SDL_STATIC_LIBS= +esac + +DOLLAR="$" +SDL_STATIC_LIBS="$DOLLAR{libdir}/libSDLmain.a $DOLLAR{libdir}/libSDL.a $SDL_STATIC_LIBS" + +### +### Features probes +### + +CONFIG_LIBC=yes + +### +### Configuration files generation +### + +# create the objs directory that is going to contain all generated files +# including the configuration ones +# +mkdir -p objs + +config_add () +{ + echo "$1" >> $config_h +} + +# used to add a macro define/undef line to the configuration +# $1: macro name +# $2: 1, 0, yes or no +# $3: optional log prefix +config_add_macro () +{ + local logname + logname="${3:-CfgMacro }" + case "$2" in + 0|no|false) + config_add "/* #undef $1 */" + log "$logname: $1=0" + ;; + 1|yes|true) + config_add "#define $1 1" + log "$logname: $1=1" + ;; + esac +} + +# used to add host-os-specific driver macros to the config file +# $1 : driver prefix, e.g. DRIVERS_VIDEO +# $2 : macro prefix +# this will look for DRIVERS_VIDEO_${HOST_OS}, and, if it is not +# defined in DRIVERS_VIDEO_default +# +# then this will call 'config_add ${2}_${driver}' for each driver listed +# +config_add_driver_macros () +{ + local driver_list="`var_value ${1}_${HOST_OS}`" + local driver_name + if [ -z "$driver_list" ] ; then + driver_list="`var_value ${1}_default`" + fi + for driver_name in $driver_list; do + config_add_macro "${2}_${driver_name}" yes + done +} + +config_h=objs/SDL_config.h + +# a function used to check the availability of a given Standard C header +# $1 : header name, without the .h suffix nor enclosing brackets (e.g. 'memory' for <memory.h>) +# this will update the configuration with a relevant line +sdl_check_header () +{ + local result + local header + local macro + header="<$1.h>" + macro=`to_uppercase $1` + macro=`echo $macro | tr '/' '_'` + feature_check_header result "$header" + config_add_macro HAVE_${macro}_H $result "StdCHeader " +} + +# call sdl_check_header with a list of header names +sdl_check_headers () +{ + for hh in $*; do + sdl_check_header "$hh" + done +} + +# a function used to check that a given function is available in the C library +# this will update the configuration with a relevant line +# $1: function name +# $2: optional, libraries to link against +# +sdl_check_func () +{ + local result + local funcname + local macro + funcname="$1" + macro=`to_uppercase $1` + rm -f $TMPC + cat > $TMPC <<EOF +#undef $funcname +#define $funcname _innocuous_$funcname +#include <assert.h> +#undef $funcname + +typedef void (*func_t)(void); +extern void $funcname(void); +func_t _dummy = $funcname; +int main(void) +{ + return _dummy == $funcname; +} +EOF + EXTRA_LDFLAGS="$2" + feature_check_link result + config_add_macro HAVE_${macro} $result "StdCFunc " +} + +# call sdl_check_func with a list of functions +sdl_check_funcs () +{ + for ff in $*; do + sdl_check_func "$ff" + done +} + +# check endianess of the host platform +sdl_check_endianess () +{ + cat > $TMPC <<EOF + int main(void) + { + union { + unsigned short v; + unsigned char b[2]; + } u; + + u.v = 0x1234; + return (u.b[0] == 0x12); + } +EOF + feature_run_exec test_e + if [ "$test_e" = "1" ] ; then + eval $1=4321 + else + eval $1=1234 + fi +} + + +generate_SDL_config_h () +{ + echo "/* This file was autogenerated by '$PROGNAME' - do not edit */" > $config_h + + config_add "#ifndef _SDL_config_h" + config_add "#define _SDL_config_h" + config_add "" + config_add "#include \"SDL_platform.h\"" + config_add "" + + # true for all architectures these days + config_add_macro SDL_HAS_64BIT_TYPE 1 + + sdl_check_endianess ENDIANESS + config_add "#define SDL_BYTEORDER $ENDIANESS" + config_add "" + + config_add_macro HAVE_LIBC $CONFIG_LIBC + + config_add "#if HAVE_LIBC" + config_add "" + config_add "/* Useful headers */" + + sdl_check_headers alloca sys/types stdio + + # just like configure - force it to 1 + config_add "#define STDC_HEADERS 1" + + sdl_check_headers stdlib stdarg malloc memory string strings inttypes stdint ctype math iconv signal altivec + + config_add "/* C library functions */" + + sdl_check_funcs malloc calloc realloc free alloc + + config_add "#ifndef _WIN32 /* Don't use on Windows */" + + sdl_check_funcs getenv putenv unsetenv + + config_add "#endif" + sdl_check_funcs qsort abs bcopy memset memcpy memmove memcmp strlen strlcpy strlcat + sdl_check_funcs strdup _strrev _strupr _strlwr index rindex strchr strrchr itoa _ltoa + sdl_check_funcs _uitoa _ultoa strtol strtoul _i64toa _ui64toa strtoll strtoull + sdl_check_funcs strtod atoi atof strcmp strncmp _stricmp strcasecmp _strnicmp + sdl_check_funcs vsnprintf iconv sigaction setjmp nanosleep + + sdl_check_func clock_gettime -lrt + sdl_check_func dlvsym -ldl + + sdl_check_funcs getpagesize + + config_add "#else" + config_add "/* We may need some replacement for stdarg.h here */" + config_add "#include <stdarg.h>" + config_add "#endif /* HAVE_LIBC */" + config_add "" + + config_add "/* Allow disabling of core subsystems */" + + config_add_macro SDL_AUDIO_DISABLED yes + config_add_macro SDL_CDROM_DISABLED yes + config_add_macro SDL_CPUINFO_DISABLED no + config_add_macro SDL_EVENTS_DISABLED no + config_add_macro SDL_FILE_DISABLED yes + config_add_macro SDL_JOYSTICK_DISABLED yes + config_add_macro SDL_LOADSO_DISABLED no + config_add_macro SDL_THREADS_DISABLED no + config_add_macro SDL_TIMERS_DISABLED no + config_add_macro SDL_VIDEO_DISABLED no + + config_add "" + config_add "/* Enable various shared object loading systems */" + + config_add_driver_macros DRIVERS_LOADSO SDL_LOADSO + + config_add "" + config_add "/* Enable various threading systems */" + + config_add_driver_macros DRIVERS_THREAD SDL_THREAD + + config_add "" + config_add "/* Enable various timer systems */" + + config_add_driver_macros DRIVERS_TIMER SDL_TIMER + + config_add "" + config_add "/* Enable various video drivers */" + + config_add_driver_macros DRIVERS_VIDEO SDL_VIDEO_DRIVER + + config_add_driver_macros DRIVERS_MAIN SDL_MAIN + + # the following defines are good enough for all recent Unix distributions + config_add "#define SDL_VIDEO_DRIVER_X11_DYNAMIC \"libX11.so.6\"" + config_add "#define SDL_VIDEO_DRIVER_X11_DYNAMIC_XEXT \"libXext.so.6\"" + config_add "#define SDL_VIDEO_DRIVER_X11_DYNAMIC_XRANDR \"libXrandr.so.2\"" + config_add "#define SDL_VIDEO_DRIVER_X11_DYNAMIC_XRENDER \"libXrender.so.1\"" + + # todo: OpenGL support ? + # todo: Assembly routines support ? + + config_add "#endif /* _SDL_config_h */" +} + +### Build the config sub-makefile +### + +make_add () +{ + echo "$1" >> $config_mk +} + +make_add_driver_macros () +{ + local driver_list="`var_value ${1}_${HOST_OS}`" + local driver_name + if [ -z "$driver_list" ] ; then + driver_list="`var_value ${1}_default`" + fi + for driver_name in $driver_list; do + make_add "SDL_$2_${driver_name} := yes" + done +} + +generate_sdl_config_mk () +{ + CFLAGS="$CFLAGS $BUILD_CFLAGS" + LDFLAGS="$LDFLAGS $BUILD_LDFLAGS" + create_config_mk + + make_add "" + PWD=`pwd` + make_add "SRC_PATH=$PWD" + make_add "BUILD_SYSTEM=$ANDROID_QEMU_PATH/android/build" + + make_add "SDL_CONFIG_LIBC := $CONFIG_LIBC" + make_add "SDL_CONFIG_CPUINFO := yes" + + make_add_driver_macros DRIVERS_LOADSO CONFIG_LOADSO + make_add_driver_macros DRIVERS_THREAD CONFIG_THREAD + make_add_driver_macros DRIVERS_TIMER CONFIG_TIMER + make_add_driver_macros DRIVERS_VIDEO CONFIG_VIDEO + + make_add_driver_macros DRIVERS_MAIN CONFIG_MAIN + + make_add "INSTALL_TARGETS := $OPTION_TARGETS" +} + +### Build the final sdl-config script from the template +### + +generate_sdl_config () +{ + # build a sed script that will replace all @VARIABLES@ in the template + # with appropriate values + rm -f $TMPC + + # replace @exec_prefix@ with "{prefix}", and @libdir@ with "{libdir}" + cat > $TMPC <<EOF +s!@exec_prefix@!\$\{prefix\}!g +s!@libdir@!\$\{exec_prefix\}/libs!g +s!@includedir@!\$\{prefix\}/include!g +EOF + + # we want to enable static linking, do @ENABLE_STATIC_FALSE@ and @ENABLE_STATIC_TRUE@ + cat >> $TMPC <<EOF +s!@ENABLE_STATIC_FALSE@!\#!g +s!@ENABLE_STATIC_TRUE@!!g +s!@ENABLE_SHARED_TRUE@!\#!g +s!@ENABLE_SHARED_FALSE@!!g +EOF + + # set the version to 1.2.15 + cat >> $TMPC <<EOF +s!@SDL_VERSION@!1.2.15!g +EOF + + # + cat >> $TMPC <<EOF +s!@SDL_CFLAGS@!$SDL_CFLAGS!g +s!@SDL_STATIC_LIBS@!$SDL_STATIC_LIBS!g +EOF + + cat sdl-config.in | sed -f $TMPC > objs/sdl-config + chmod +x objs/sdl-config +} + +# copy a configuration file or perform auto-detection if one is not available +# or the --force-autodetect option was used +# $1: basename of config file +# $2: command to run to perform auto-detection/generation +# +copy_or_autodetect () +{ + if [ "$OPTION_FORCE_AUTODETECT" != "yes" -a -f android/build/$OS/$1 ] ; then + log "Setup : Copying $1 from android/build/$OS" + cp -f android/build/$OS/$1 objs/$1 + else + log "Setup : Auto-generating $1" + eval $2 + fi +} + +generate_all () +{ + copy_or_autodetect SDL_config.h generate_SDL_config_h + generate_sdl_config_mk + copy_or_autodetect sdl-config generate_sdl_config +} + +DRIVERS_LOADSO_default=DLOPEN +DRIVERS_LOADSO_darwin=DLCOMPAT +DRIVERS_LOADSO_windows=WIN32 + +# TODO: determine if PTHREAD_RECURSIVE or PTHREAD_RECURSIVE_NP is valid for the platform +DRIVERS_THREAD_default="PTHREAD PTHREAD_RECURSIVE_MUTEX" +DRIVERS_THREAD_linux="PTHREAD PTHREAD_RECURSIVE_MUTEX_NP" +DRIVERS_THREAD_windows=WIN32 + +DRIVERS_TIMER_default=UNIX +DRIVERS_TIMER_windows=WIN32 + +# TODO: actually compute this properly for X11 and dynamic loading !! +DRIVERS_VIDEO_default="X11 X11_DPMS X11_XINERAMA X11_XME" +DRIVERS_VIDEO_darwin="QUARTZ" +DRIVERS_VIDEO_windows="WINDIB" + +DRIVERS_MAIN_default=DUMMY +DRIVERS_MAIN_darwin=MACOSX +DRIVERS_MAIN_windows=WIN32 + +generate_all diff --git a/distrib/sdl-1.2.15/include/SDL_syswm.h b/distrib/sdl-1.2.15/include/SDL_syswm.h index 78433c6..771d6b1 100644 --- a/distrib/sdl-1.2.15/include/SDL_syswm.h +++ b/distrib/sdl-1.2.15/include/SDL_syswm.h @@ -181,6 +181,18 @@ typedef struct SDL_SysWMinfo { int data; } SDL_SysWMinfo; +#elif defined(SDL_VIDEO_DRIVER_QUARTZ) + +struct SDL_SysWMmsg { + SDL_version version; + int data; +}; + +typedef struct SDL_SysWMinfo { + SDL_version version; + void* nsWindowPtr; +} SDL_SysWMinfo; + #else /** The generic custom event structure */ diff --git a/distrib/sdl-1.2.15/include/SDL_video.h b/distrib/sdl-1.2.15/include/SDL_video.h index f9c4e07..9a2df0c 100644 --- a/distrib/sdl-1.2.15/include/SDL_video.h +++ b/distrib/sdl-1.2.15/include/SDL_video.h @@ -936,6 +936,36 @@ typedef enum { */ extern DECLSPEC SDL_GrabMode SDLCALL SDL_WM_GrabInput(SDL_GrabMode mode); +/* + * Move the SDL Window to a specific position. Does nothing in fullscreen mode. + */ +extern DECLSPEC void SDL_WM_SetPos(int x, int y); + +/* + * Get the current SDL window position. Returns (0,0) in fullscreen mode. + */ +extern DECLSPEC void SDL_WM_GetPos(int *px, int *py); + +/* + * If the window is fully visible, return TRUE; otherwise, recenter the window + * if the 'recenter' parameter is non-0, and return FALSE. + */ +extern DECLSPEC int SDL_WM_IsFullyVisible(int recenter); + +/* + * Get the resolution of the main monitor in DPIs, if available. + * Return 0 on success, or -1 if the data is not available. + */ +extern DECLSPEC int SDL_WM_GetMonitorDPI(int *xDPI, int *yDPI); + +/* + * Get the coordinates of the monitor in virtual desktop space. + * In the case of multi-monitor systems, returns the rectangle of + * the 'nearest' monitor relative to the main SDL_window. Returns + * 0 on success, or -1 if the data is not available. + */ +extern DECLSPEC int SDL_WM_GetMonitorRect(SDL_Rect *rect); + /*@}*/ /** @internal Not in public API at the moment - do not use! */ diff --git a/distrib/sdl-1.2.15/sdl-config.in b/distrib/sdl-1.2.15/sdl-config.in index e0fcc0c..843c1a6 100644 --- a/distrib/sdl-1.2.15/sdl-config.in +++ b/distrib/sdl-1.2.15/sdl-config.in @@ -1,6 +1,7 @@ #!/bin/sh -prefix=@prefix@ +curdir=`dirname $0` +prefix=`dirname $curdir` exec_prefix=@exec_prefix@ exec_prefix_set=no libdir=@libdir@ @@ -49,7 +50,7 @@ while test $# -gt 0; do @ENABLE_SHARED_TRUE@ ;; @ENABLE_STATIC_TRUE@@ENABLE_SHARED_TRUE@ --static-libs) @ENABLE_STATIC_TRUE@@ENABLE_SHARED_FALSE@ --libs|--static-libs) -@ENABLE_STATIC_TRUE@ echo -L@libdir@ @SDL_RLD_FLAGS@ @SDL_STATIC_LIBS@ +@ENABLE_STATIC_TRUE@ echo @SDL_STATIC_LIBS@ @ENABLE_STATIC_TRUE@ ;; *) echo "${usage}" 1>&2 diff --git a/distrib/sdl-1.2.15/sources.make b/distrib/sdl-1.2.15/sources.make new file mode 100644 index 0000000..5117506 --- /dev/null +++ b/distrib/sdl-1.2.15/sources.make @@ -0,0 +1,243 @@ +# This is included from the main Android emulator build script +# to declare the SDL-related sources, compiler flags and libraries +# + +SDL_CFLAGS := +SDL_LDLIBS := +SDL_STATIC_LIBRARIES := + +SDL_SOURCES := + +ifeq ($(HOST_OS),linux) + SDL_CONFIG_LOADSO_DLOPEN := yes + SDL_CONFIG_THREAD_PTHREAD := yes + SDL_CONFIG_THREAD_PTHREAD_RECURSIVE_MUTEX_NP := yes + SDL_CONFIG_TIMER_UNIX := yes + SDL_CONFIG_VIDEO_X11 := yes + SDL_CONFIG_VIDEO_X11_DPMS := yes + SDL_CONFIG_VIDEO_X11_XINERAMA := yes + SDL_CONFIG_VIDEO_X11_XME := yes + SDL_CONFIG_MAIN_DUMMY := yes + + SDL_CFLAGS += -D_GNU_SOURCE=1 -D_REENTRANT + SDL_LDLIBS += -lm -ldl -lpthread -lrt +endif + +ifeq ($(HOST_OS),freebsd) + SDL_CONFIG_LOADSO_DLOPEN := yes + SDL_CONFIG_THREAD_PTHREAD := yes + SDL_CONFIG_THREAD_PTHREAD_RECURSIVE_MUTEX := yes + SDL_CONFIG_TIMER_UNIX := yes + SDL_CONFIG_VIDEO_X11 := yes + SDL_CONFIG_VIDEO_X11_DPMS := yes + SDL_CONFIG_VIDEO_X11_XINERAMA := yes + SDL_CONFIG_VIDEO_X11_XME := yes + SDL_CONFIG_MAIN_DUMMY := yes + + SDL_CFLAGS += -D_GNU_SOURCE=1 -D_REENTRANT + SDL_LDLIBS += -lm -ldl -lpthread +endif + +ifeq ($(HOST_OS),darwin) + SDL_CONFIG_LOADSO_DLCOMPAT := yes + SDL_CONFIG_THREAD_PTHREAD := yes + SDL_CONFIG_THREAD_PTHREAD_RECURSIVE_MUTEX := yes + SDL_CONFIG_TIMER_UNIX := yes + SDL_CONFIG_VIDEO_QUARTZ := yes + SDL_CONFIG_MAIN_MACOSX := yes + + SDL_CFLAGS += -D_GNU_SOURCE=1 -DTHREAD_SAFE + FRAMEWORKS := OpenGL Cocoa QuickTime ApplicationServices Carbon IOKit + SDL_LDLIBS += $(FRAMEWORKS:%=-Wl,-framework,%) +endif + +ifeq ($(HOST_OS),windows) + SDL_CONFIG_LOADSO_WIN32 := yes + SDL_CONFIG_THREAD_WIN32 := yes + SDL_CONFIG_TIMER_WIN32 := yes + SDL_CONFIG_VIDEO_WINDIB := yes + SDL_CONFIG_MAIN_WIN32 := yes + + SDL_CFLAGS += -D_GNU_SOURCE=1 -Dmain=SDL_main -DNO_STDIO_REDIRECT=1 + SDL_LDLIBS += -luser32 -lgdi32 -lwinmm +endif + + +# the main src/ sources +# +SRCS := SDL.c \ + SDL_error.c \ + SDL_fatal.c \ + +SRCS += events/SDL_active.c \ + events/SDL_events.c \ + events/SDL_expose.c \ + events/SDL_keyboard.c \ + events/SDL_mouse.c \ + events/SDL_quit.c \ + events/SDL_resize.c \ + +SRCS += file/SDL_rwops.c + +SRCS += stdlib/SDL_getenv.c \ + stdlib/SDL_iconv.c \ + stdlib/SDL_malloc.c \ + stdlib/SDL_qsort.c \ + stdlib/SDL_stdlib.c \ + stdlib/SDL_string.c + +SRCS += cpuinfo/SDL_cpuinfo.c + +SDL_SOURCES += $(SRCS:%=$(SDL_DIR)/src/%) + +# the LoadSO sources +# + +SRCS := + +ifeq ($(SDL_CONFIG_LOADSO_DLOPEN),yes) + SRCS += dlopen/SDL_sysloadso.c + SDL_LDLIBS += -ldl +endif + +ifeq ($(SDL_CONFIG_LOADSO_DLCOMPAT),yes) + SRCS += macosx/SDL_dlcompat.c +endif + +ifeq ($(SDL_CONFIG_LOADSO_WIN32),yes) + SRCS += win32/SDL_sysloadso.c +endif + +SDL_SOURCES += $(SRCS:%=$(SDL_DIR)/src/loadso/%) + +# the Thread sources +# + +SRCS := SDL_thread.c + +ifeq ($(SDL_CONFIG_THREAD_PTHREAD),yes) + SRCS += pthread/SDL_syscond.c \ + pthread/SDL_sysmutex.c \ + pthread/SDL_syssem.c \ + pthread/SDL_systhread.c +endif + +ifeq ($(SDL_CONFIG_THREAD_WIN32),yes) + SRCS += win32/SDL_sysmutex.c \ + win32/SDL_syssem.c \ + win32/SDL_systhread.c +endif + +SDL_SOURCES += $(SRCS:%=$(SDL_DIR)/src/thread/%) + +# the Timer sources +# + +SRCS := SDL_timer.c + +ifeq ($(SDL_CONFIG_TIMER_UNIX),yes) + SRCS += unix/SDL_systimer.c +endif + +ifeq ($(SDL_CONFIG_TIMER_WIN32),yes) + SRCS += win32/SDL_systimer.c +endif + +SDL_SOURCES += $(SRCS:%=$(SDL_DIR)/src/timer/%) + +# the Video sources +# + +SRCS := SDL_RLEaccel.c \ + SDL_blit.c \ + SDL_blit_0.c \ + SDL_blit_1.c \ + SDL_blit_A.c \ + SDL_blit_N.c \ + SDL_bmp.c \ + SDL_cursor.c \ + SDL_gamma.c \ + SDL_pixels.c \ + SDL_stretch.c \ + SDL_surface.c \ + SDL_video.c \ + SDL_yuv.c \ + SDL_yuv_mmx.c \ + SDL_yuv_sw.c \ + +SRCS += dummy/SDL_nullevents.c \ + dummy/SDL_nullmouse.c \ + dummy/SDL_nullvideo.c + +ifeq ($(SDL_CONFIG_VIDEO_WINDIB),yes) + SRCS += windib/SDL_dibevents.c \ + windib/SDL_dibvideo.c \ + wincommon/SDL_sysevents.c \ + wincommon/SDL_sysmouse.c \ + wincommon/SDL_syswm.c \ + wincommon/SDL_wingl.c +endif + +ifeq ($(SDL_CONFIG_VIDEO_QUARTZ),yes) + SRCS += quartz/SDL_QuartzGL.m \ + quartz/SDL_QuartzVideo.m \ + quartz/SDL_QuartzWM.m \ + quartz/SDL_QuartzWindow.m \ + quartz/SDL_QuartzEvents.m \ + maccommon/SDL_macevents.c \ + maccommon/SDL_macgl.c \ + maccommon/SDL_macmouse.c \ + maccommon/SDL_macwm.c + +endif + +ifeq ($(SDL_CONFIG_VIDEO_X11),yes) + SRCS += x11/SDL_x11dyn.c \ + x11/SDL_x11dga.c \ + x11/SDL_x11events.c \ + x11/SDL_x11gamma.c \ + x11/SDL_x11gl.c \ + x11/SDL_x11image.c \ + x11/SDL_x11modes.c \ + x11/SDL_x11mouse.c \ + x11/SDL_x11video.c \ + x11/SDL_x11wm.c \ + x11/SDL_x11yuv.c +endif + +ifeq ($(SDL_CONFIG_VIDEO_X11_DGAMOUSE),yes) + SRCS += x11/SDL_x11dga.c +endif + +ifeq ($(SDL_CONFIG_VIDEO_X11_XME),yes) + SRCS += Xext/XME/xme.c +endif + +ifeq ($(SDL_CONFIG_VIDEO_X11_XINERAMA),yes) + SRCS += Xext/Xinerama/Xinerama.c +endif + +ifeq ($(SDL_CONFIG_VIDEO_X11_XV),yes) + SRCS += Xext/Xv/Xv.c +endif + +SDL_SOURCES += $(SRCS:%=$(SDL_DIR)/src/video/%) + +## Build libSDLmain +## + +SRCS := + +ifeq ($(SDL_CONFIG_MAIN_DUMMY),yes) + SRCS += dummy/SDL_dummy_main.c +endif + +ifeq ($(SDL_CONFIG_MAIN_MACOSX),yes) + SRCS += macosx/SDLMain.m +endif + +ifeq ($(SDL_CONFIG_MAIN_WIN32),yes) + SRCS += win32/SDL_win32_main.c +endif + +SDLMAIN_SOURCES := $(SRCS:%=$(SDL_DIR)/src/main/%) diff --git a/distrib/sdl-1.2.15/src/audio/macosx/SDL_coreaudio.h b/distrib/sdl-1.2.15/src/audio/macosx/SDL_coreaudio.h index c11bc03..3f0e218 100644 --- a/distrib/sdl-1.2.15/src/audio/macosx/SDL_coreaudio.h +++ b/distrib/sdl-1.2.15/src/audio/macosx/SDL_coreaudio.h @@ -25,6 +25,7 @@ #define _SDL_coreaudio_h #include "../SDL_sysaudio.h" +#include <AudioUnit/AUNTComponent.h> /* Hidden "this" pointer for the video functions */ #define _THIS SDL_AudioDevice *this diff --git a/distrib/sdl-1.2.15/src/audio/windib/SDL_dibaudio.c b/distrib/sdl-1.2.15/src/audio/windib/SDL_dibaudio.c index 51a9a4d..b218ff9 100644 --- a/distrib/sdl-1.2.15/src/audio/windib/SDL_dibaudio.c +++ b/distrib/sdl-1.2.15/src/audio/windib/SDL_dibaudio.c @@ -45,6 +45,10 @@ static void DIB_PlayAudio(_THIS); static void DIB_WaitDone(_THIS); static void DIB_CloseAudio(_THIS); +int volatile dibaudio_thread_debug = 0; +int volatile dibaudio_cb_debug = 0; +int volatile dibaudio_main_debug = 0; + /* Audio driver bootstrap functions */ static int Audio_Available(void) @@ -109,11 +113,13 @@ static void CALLBACK FillSound(HWAVEOUT hwo, UINT uMsg, DWORD_PTR dwInstance, return; /* Signal that we are done playing a buffer */ -#if defined(_WIN32_WCE) && (_WIN32_WCE < 300) - ReleaseSemaphoreCE(audio_sem, 1, NULL); -#else - ReleaseSemaphore(audio_sem, 1, NULL); -#endif + dibaudio_cb_debug = 1; + EnterCriticalSection(&audio_cs); + dibaudio_cb_debug = 2; + SetEvent(audio_event); + dibaudio_cb_debug = 3; + LeaveCriticalSection(&audio_cs); + dibaudio_cb_debug = 4; } static void SetMMerror(char *function, MMRESULT code) @@ -147,17 +153,20 @@ static void DIB_ThreadInit(_THIS) void DIB_WaitAudio(_THIS) { /* Wait for an audio chunk to finish */ -#if defined(_WIN32_WCE) && (_WIN32_WCE < 300) - WaitForSemaphoreCE(audio_sem, INFINITE); -#else - WaitForSingleObject(audio_sem, INFINITE); -#endif + dibaudio_thread_debug = 1; + WaitForSingleObject(audio_event, INFINITE); + dibaudio_thread_debug = 2; + ResetEvent(audio_event); + dibaudio_thread_debug = 3; } Uint8 *DIB_GetAudioBuf(_THIS) { Uint8 *retval; + dibaudio_thread_debug = 4; + EnterCriticalSection(&audio_cs); + dibaudio_thread_debug = 5; retval = (Uint8 *)(wavebuf[next_buffer].lpData); return retval; } @@ -165,14 +174,23 @@ Uint8 *DIB_GetAudioBuf(_THIS) void DIB_PlayAudio(_THIS) { /* Queue it up */ + dibaudio_thread_debug = 6; waveOutWrite(sound, &wavebuf[next_buffer], sizeof(wavebuf[0])); + dibaudio_thread_debug = 7; next_buffer = (next_buffer+1)%NUM_BUFFERS; + LeaveCriticalSection(&audio_cs); + dibaudio_thread_debug = 8; } void DIB_WaitDone(_THIS) { - int i, left; + int i, left, tries = 5; + dibaudio_thread_debug = 9; + + /* give some time for the wave output to send the last buffer, + but don't hang if one was cancelled + */ do { left = NUM_BUFFERS; for ( i=0; i<NUM_BUFFERS; ++i ) { @@ -180,10 +198,13 @@ void DIB_WaitDone(_THIS) --left; } } - if ( left > 0 ) { - SDL_Delay(100); - } - } while ( left > 0 ); + if ( left == 0 ) + break; + + SDL_Delay(100); + } while ( --tries > 0 ); + + dibaudio_thread_debug = 10; } void DIB_CloseAudio(_THIS) @@ -191,15 +212,15 @@ void DIB_CloseAudio(_THIS) int i; /* Close up audio */ - if ( audio_sem ) { + if (audio_event != INVALID_HANDLE_VALUE ) { #if defined(_WIN32_WCE) && (_WIN32_WCE < 300) - CloseSynchHandle(audio_sem); + CloseSynchHandle(audio_event); #else - CloseHandle(audio_sem); + CloseHandle(audio_event); #endif } if ( sound ) { - waveOutClose(sound); + waveOutReset(sound); } /* Clean up mixing buffers */ @@ -215,6 +236,9 @@ void DIB_CloseAudio(_THIS) SDL_free(mixbuf); mixbuf = NULL; } + + if ( sound ) + waveOutClose(sound); } int DIB_OpenAudio(_THIS, SDL_AudioSpec *spec) @@ -225,7 +249,8 @@ int DIB_OpenAudio(_THIS, SDL_AudioSpec *spec) /* Initialize the wavebuf structures for closing */ sound = NULL; - audio_sem = NULL; + InitializeCriticalSection(&audio_cs); + audio_event = INVALID_HANDLE_VALUE; for ( i = 0; i < NUM_BUFFERS; ++i ) wavebuf[i].dwUser = 0xFFFF; mixbuf = NULL; @@ -287,12 +312,8 @@ int DIB_OpenAudio(_THIS, SDL_AudioSpec *spec) #endif /* Create the audio buffer semaphore */ -#if defined(_WIN32_WCE) && (_WIN32_WCE < 300) - audio_sem = CreateSemaphoreCE(NULL, NUM_BUFFERS-1, NUM_BUFFERS, NULL); -#else - audio_sem = CreateSemaphore(NULL, NUM_BUFFERS-1, NUM_BUFFERS, NULL); -#endif - if ( audio_sem == NULL ) { + audio_event = CreateEvent( NULL, TRUE, FALSE, NULL ); + if (audio_event == NULL) { SDL_SetError("Couldn't create semaphore"); return(-1); } diff --git a/distrib/sdl-1.2.15/src/audio/windib/SDL_dibaudio.h b/distrib/sdl-1.2.15/src/audio/windib/SDL_dibaudio.h index d2c6228..16fd078 100644 --- a/distrib/sdl-1.2.15/src/audio/windib/SDL_dibaudio.h +++ b/distrib/sdl-1.2.15/src/audio/windib/SDL_dibaudio.h @@ -33,17 +33,21 @@ struct SDL_PrivateAudioData { HWAVEOUT sound; - HANDLE audio_sem; - Uint8 *mixbuf; /* The raw allocated mixing buffer */ + CRITICAL_SECTION audio_cs; + HANDLE audio_event; + Uint8* mixbuf; /* The raw allocated mixing buffer */ WAVEHDR wavebuf[NUM_BUFFERS]; /* Wave audio fragments */ + int cur_buffer; int next_buffer; }; /* Old variable names */ #define sound (this->hidden->sound) -#define audio_sem (this->hidden->audio_sem) +#define audio_event (this->hidden->audio_event) +#define audio_cs (this->hidden->audio_cs) #define mixbuf (this->hidden->mixbuf) #define wavebuf (this->hidden->wavebuf) +#define cur_buffer (this->hidden->cur_buffer) #define next_buffer (this->hidden->next_buffer) #endif /* _SDL_lowaudio_h */ diff --git a/distrib/sdl-1.2.15/src/main/macosx/SDLMain.m b/distrib/sdl-1.2.15/src/main/macosx/SDLMain.m index 2434f81..7da74b6 100644 --- a/distrib/sdl-1.2.15/src/main/macosx/SDLMain.m +++ b/distrib/sdl-1.2.15/src/main/macosx/SDLMain.m @@ -371,6 +371,20 @@ int main (int argc, char **argv) gFinderLaunch = NO; } +/* ANDROID_BEGIN */ + /* if -no-window is used, we don't want to launch a graphical + * application that creates a Menu bar and steals the focus. + */ + { + int nn; + for (nn = 0; nn < argc; nn++) { + if ( !strcmp( argv[nn], "-no-window" ) ) { + return SDL_main (argc, argv); + } + } + } +/* ANDROID_END */ + #if SDL_USE_NIB_FILE NSApplicationMain (argc, argv); #else diff --git a/distrib/sdl-1.2.15/src/video/SDL_sysvideo.h b/distrib/sdl-1.2.15/src/video/SDL_sysvideo.h index 436450e..65287b4 100644 --- a/distrib/sdl-1.2.15/src/video/SDL_sysvideo.h +++ b/distrib/sdl-1.2.15/src/video/SDL_sysvideo.h @@ -217,6 +217,21 @@ struct SDL_VideoDevice { /* Get some platform dependent window information */ int (*GetWMInfo)(_THIS, SDL_SysWMinfo *info); + /* set window position */ + void (*SetWindowPos)(_THIS, int x, int y); + + /* get window position */ + void (*GetWindowPos)(_THIS, int *px, int *py); + + /* determine if the window is fully visible on screen */ + int (*IsWindowVisible)(_THIS, int recenter); + + /* get main monitor's resolution */ + int (*GetMonitorDPI)(_THIS, int *xdpi, int *ydpi); + + /* get nearest monitor's rectangle */ + int (*GetMonitorRect)(_THIS, SDL_Rect* rect); + /* * * */ /* Cursor manager functions */ diff --git a/distrib/sdl-1.2.15/src/video/SDL_video.c b/distrib/sdl-1.2.15/src/video/SDL_video.c index 46285c9..43c1826 100644 --- a/distrib/sdl-1.2.15/src/video/SDL_video.c +++ b/distrib/sdl-1.2.15/src/video/SDL_video.c @@ -1963,6 +1963,66 @@ int SDL_WM_ToggleFullScreen(SDL_Surface *surface) } /* + * Set window position + */ +void SDL_WM_SetPos(int x, int y) +{ + SDL_VideoDevice* video = current_video; + + if (video && video->SetWindowPos) + video->SetWindowPos(video, x, y); +} + +/* + * Get window position + */ +void SDL_WM_GetPos(int *px, int *py) +{ + SDL_VideoDevice* video = current_video; + + if (video && video->GetWindowPos) + video->GetWindowPos(video, px, py); + else { + *px = 100; + *py = 100; + } +} + +int SDL_WM_IsFullyVisible( int recenter ) +{ + int result = 1; + + SDL_VideoDevice* video = current_video; + + if (video && video->IsWindowVisible) { + result = video->IsWindowVisible(video, recenter); + } + return result; +} + +int SDL_WM_GetMonitorDPI( int *xDpi, int *yDpi ) +{ + int result = -1; + SDL_VideoDevice* video = current_video; + + if (video && video->GetMonitorDPI) { + result = video->GetMonitorDPI(video, xDpi, yDpi); + } + return result; +} + +int SDL_WM_GetMonitorRect( SDL_Rect *rect ) +{ + int result = -1; + SDL_VideoDevice* video = current_video; + + if (video && video->GetMonitorRect) { + result = video->GetMonitorRect(video, rect); + } + return result; +} + +/* * Get some platform dependent window manager information */ int SDL_GetWMInfo (SDL_SysWMinfo *info) diff --git a/distrib/sdl-1.2.15/src/video/Xext/Xxf86dga/XF86DGA.c b/distrib/sdl-1.2.15/src/video/Xext/Xxf86dga/XF86DGA.c index fc729f1..f2210e4 100644 --- a/distrib/sdl-1.2.15/src/video/Xext/Xxf86dga/XF86DGA.c +++ b/distrib/sdl-1.2.15/src/video/Xext/Xxf86dga/XF86DGA.c @@ -605,10 +605,10 @@ SDL_NAME(XF86DGAForkApp)(int screen) SDL_NAME(XF86DGADirectVideoLL)(sp->display, sp->screen, 0); XSync(sp->display, False); } - if (WIFEXITED(status)) - _exit(0); + if (WIFEXITED(status)) + exit(0); else - _exit(-1); + exit(-1); } return pid; } @@ -657,7 +657,7 @@ XF86cleanup(int sig) static char beenhere = 0; if (beenhere) - _exit(3); + exit(3); beenhere = 1; for (i = 0; i < numScrs; i++) { @@ -665,7 +665,7 @@ XF86cleanup(int sig) SDL_NAME(XF86DGADirectVideo)(sp->display, sp->screen, 0); XSync(sp->display, False); } - _exit(3); + exit(3); } Bool diff --git a/distrib/sdl-1.2.15/src/video/quartz/SDL_QuartzVideo.h b/distrib/sdl-1.2.15/src/video/quartz/SDL_QuartzVideo.h index 7506e0c..d00e496 100644 --- a/distrib/sdl-1.2.15/src/video/quartz/SDL_QuartzVideo.h +++ b/distrib/sdl-1.2.15/src/video/quartz/SDL_QuartzVideo.h @@ -215,6 +215,12 @@ void QZ_PumpEvents (_THIS); void QZ_SetCaption (_THIS, const char *title, const char *icon); void QZ_SetIcon (_THIS, SDL_Surface *icon, Uint8 *mask); int QZ_IconifyWindow (_THIS); +void QZ_SetWindowPos (_THIS, int x, int y); +void QZ_GetWindowPos (_THIS, int *px, int *py); +int QZ_IsWindowVisible (_THIS, int recenter); +int QZ_GetMonitorDPI (_THIS, int *xDpi, int *yDpi); +int QZ_GetMonitorRect (_THIS, SDL_Rect *rect); + SDL_GrabMode QZ_GrabInput (_THIS, SDL_GrabMode grab_mode); /*int QZ_GetWMInfo (_THIS, SDL_SysWMinfo *info);*/ diff --git a/distrib/sdl-1.2.15/src/video/quartz/SDL_QuartzVideo.m b/distrib/sdl-1.2.15/src/video/quartz/SDL_QuartzVideo.m index fa04e9d..bb20172 100644 --- a/distrib/sdl-1.2.15/src/video/quartz/SDL_QuartzVideo.m +++ b/distrib/sdl-1.2.15/src/video/quartz/SDL_QuartzVideo.m @@ -23,6 +23,7 @@ #include "SDL_QuartzVideo.h" #include "SDL_QuartzWindow.h" +#include "SDL_QuartzWM.h" /* These APIs aren't just deprecated; they're gone from the headers in the 10.7 SDK. If we're using a >= 10.7 SDK, but targeting < 10.7, then we @@ -220,7 +221,12 @@ static SDL_VideoDevice* QZ_CreateDevice (int device_index) device->SetCaption = QZ_SetCaption; device->SetIcon = QZ_SetIcon; device->IconifyWindow = QZ_IconifyWindow; - /*device->GetWMInfo = QZ_GetWMInfo;*/ + device->SetWindowPos = QZ_SetWindowPos; + device->GetWindowPos = QZ_GetWindowPos; + device->IsWindowVisible = QZ_IsWindowVisible; + device->GetMonitorDPI = QZ_GetMonitorDPI; + device->GetMonitorRect = QZ_GetMonitorRect; + device->GetWMInfo = QZ_GetWMInfo; device->GrabInput = QZ_GrabInput; /* diff --git a/distrib/sdl-1.2.15/src/video/quartz/SDL_QuartzWM.h b/distrib/sdl-1.2.15/src/video/quartz/SDL_QuartzWM.h index 0b0767e..5219a59 100644 --- a/distrib/sdl-1.2.15/src/video/quartz/SDL_QuartzWM.h +++ b/distrib/sdl-1.2.15/src/video/quartz/SDL_QuartzWM.h @@ -25,3 +25,4 @@ struct WMcursor { }; void QZ_UpdateCursor(_THIS); +int QZ_GetWMInfo (_THIS, SDL_SysWMinfo *info); diff --git a/distrib/sdl-1.2.15/src/video/quartz/SDL_QuartzWM.m b/distrib/sdl-1.2.15/src/video/quartz/SDL_QuartzWM.m index d526424..b40abf8 100644 --- a/distrib/sdl-1.2.15/src/video/quartz/SDL_QuartzWM.m +++ b/distrib/sdl-1.2.15/src/video/quartz/SDL_QuartzWM.m @@ -278,6 +278,137 @@ void QZ_SetCaption (_THIS, const char *title, const char *icon) { } } +void QZ_SetWindowPos (_THIS, int x, int y) +{ + if ( qz_window == nil ) { + //printf( "%s(%d,%d): called for NULL window\n", __FUNCTION__, x, y ); + return; + } + + [ qz_window setFrameTopLeftPoint:NSMakePoint( x, this->hidden->height - y ) ]; + //printf( "%s(%d,%d): done\n", __FUNCTION__, x, y ); +} + +void QZ_GetWindowPos(_THIS, int *px, int *py) +{ + NSPoint pt; + + *px = *py = 0; + + if ( qz_window == NULL ) { + //printf( "%s: called on NULL window\n", __FUNCTION__ ); + } + + if ( qz_window != nil ) { + NSRect rect = [ qz_window frame ]; + *px = rect.origin.x; + *py = this->hidden->height - rect.origin.y - rect.size.height; + //printf( "%s: returning (%d,%d)\n", __FUNCTION__, *px, *py ); + } +} + +/* determine if the window is fully visible on the current screen configuration */ +int QZ_IsWindowVisible(_THIS, int recenter) +{ + int result = 0; + + //printf( "... enter %s\n", __FUNCTION__ ); + + if ( qz_window != NULL ) { + NSRect frame = [ qz_window frame ]; + NSArray* screens = [ NSScreen screens ]; + unsigned int count = [ screens count ]; + unsigned int n; + //printf( "window frame (%d,%d) (%d,%d)\n", frame.origin.x, frame.origin.y, + // frame.size.width, frame.size.height ); + for (n = 0; n < count; n++) { + NSScreen* screen = [ screens objectAtIndex: n ]; + NSRect vis = [ screen visibleFrame ]; + + //printf( "screen %d/%d frame (%d,%d) (%d,%d)\n", n+1, count, + // vis.origin.x, vis.origin.y, vis.size.width, vis.size.height ); + + if (frame.origin.x >= vis.origin.x && + frame.origin.x + frame.size.width <= vis.origin.x + vis.size.width && + frame.origin.y >= vis.origin.y && + frame.origin.y + frame.size.height <= vis.origin.y + vis.size.height ) + { + result = 1; + break; + } + } + } + //printf ( "... exit %s, result = %d\n", __FUNCTION__, result ); + if ( !result && recenter ) { + [ qz_window center ] ; + } + return result; +} + +int QZ_GetMonitorDPI(_THIS, int *xDpi, int *yDpi) +{ + /* FIXME: how to get this information from Cocoa ? */ + return -1; +} + +int QZ_GetMonitorRect (_THIS, SDL_Rect *rect) +{ + NSWindow* window = qz_window; + NSRect frame = [ window frame ]; + int fx1 = frame.origin.x; + int fy1 = frame.origin.y; + int fx2 = frame.size.width + fx1; + int fy2 = frame.size.height + fy1; + NSArray* screens = [ NSScreen screens ]; + unsigned int count = [ screens count ]; + int bestScreen = -1; + int bestArea = 0; + + unsigned int n; + + /* we need to compute which screen has the most window pixels */ + for (n = 0; n < count; n++) { + NSScreen* screen = [ screens objectAtIndex: n ]; + NSRect vis = [ screen visibleFrame ]; + int vx1 = vis.origin.x; + int vy1 = vis.origin.y; + int vx2 = vis.size.width + vx1; + int vy2 = vis.size.height + vy1; + int cx1, cx2, cy1, cy2, cArea; + + if (fx1 >= vx2 || vx1 >= fx2 || fy1 >= vy2 || vy1 >= fy2) + continue; + + cx1 = (fx1 < vx1) ? vx1 : fx1; + cx2 = (fx2 > vx2) ? vx2 : fx2; + cy1 = (fy1 < vy1) ? vy1 : fy1; + cy2 = (fy2 > vy2) ? vy2 : fy2; + + if (cx1 >= cx2 || cy1 >= cy2) + continue; + + cArea = (cx2-cx1)*(cy2-cy1); + + if (bestScreen < 0 || cArea > bestArea) { + bestScreen = n; + bestArea = cArea; + } + } + if (bestScreen < 0) + bestScreen = 0; + + { + NSScreen* screen = [ screens objectAtIndex: bestScreen ]; + NSRect vis = [ screen visibleFrame ]; + + rect->x = vis.origin.x; + rect->y = vis.origin.y; + rect->w = vis.size.width; + rect->h = vis.size.height; + } + return 0; +} + void QZ_SetIcon (_THIS, SDL_Surface *icon, Uint8 *mask) { NSBitmapImageRep *imgrep; @@ -362,11 +493,10 @@ int QZ_IconifyWindow (_THIS) { } } -/* int QZ_GetWMInfo (_THIS, SDL_SysWMinfo *info) { info->nsWindowPtr = qz_window; return 0; -}*/ +} void QZ_ChangeGrabState (_THIS, int action) { diff --git a/distrib/sdl-1.2.15/src/video/windib/SDL_dibvideo.c b/distrib/sdl-1.2.15/src/video/windib/SDL_dibvideo.c index 6187bfc..9f1ffff 100644 --- a/distrib/sdl-1.2.15/src/video/windib/SDL_dibvideo.c +++ b/distrib/sdl-1.2.15/src/video/windib/SDL_dibvideo.c @@ -115,6 +115,12 @@ static void DIB_RealizePalette(_THIS); static void DIB_PaletteChanged(_THIS, HWND window); static void DIB_WinPAINT(_THIS, HDC hdc); +static void DIB_GetWinPos(_THIS, int* px, int *py); +static void DIB_SetWinPos(_THIS, int x, int y); +static int DIB_IsWinVisible(_THIS, int recenter); +static int DIB_GetMonitorDPI(_THIS, int* xDpi, int *yDpi); +static int DIB_GetMonitorRect(_THIS, SDL_Rect* rect); + /* helper fn */ static int DIB_SussScreenDepth(); @@ -212,6 +218,12 @@ static SDL_VideoDevice *DIB_CreateDevice(int devindex) device->InitOSKeymap = DIB_InitOSKeymap; device->PumpEvents = DIB_PumpEvents; + device->GetWindowPos = DIB_GetWinPos; + device->SetWindowPos = DIB_SetWinPos; + device->IsWindowVisible = DIB_IsWinVisible; + device->GetMonitorDPI = DIB_GetMonitorDPI; + device->GetMonitorRect = DIB_GetMonitorRect; + /* Set up the windows message handling functions */ WIN_Activate = DIB_Activate; WIN_RealizePalette = DIB_RealizePalette; @@ -1314,6 +1326,170 @@ static void DIB_WinPAINT(_THIS, HDC hdc) DeleteDC(mdc); } +static void DIB_GetWinPos(_THIS, int* px, int *py) +{ + RECT rect; + GetWindowRect(SDL_Window, &rect); + *px = rect.left; + *py = rect.top; +} + +static void DIB_SetWinPos(_THIS, int x, int y) +{ + SetWindowPos(SDL_Window, HWND_TOPMOST, + x, y, 0, 0, SWP_NOSIZE|SWP_NOZORDER); +} + +typedef struct { + int result; + int first; + RECT wrect; + RECT primary; +} VisibilityData; + + +BOOL CALLBACK visibility_cb(HMONITOR hMonitor, + HDC hdcMonitor, + LPRECT mrect, + LPARAM dwData) +{ + VisibilityData* data = (VisibilityData*)dwData; + + if ( data->first ) { + data->first = 0; + data->primary = mrect[0]; + } + + if ( data->wrect.left >= mrect->left && + data->wrect.right <= mrect->right && + data->wrect.top >= mrect->top && + data->wrect.bottom <= mrect->bottom ) + { + data->result = 1; + return FALSE; + } + return TRUE; +} + +static int DIB_IsWinVisible(_THIS, int recenter) +{ + VisibilityData data; + data.result = 0; + data.first = 1; + + GetWindowRect(SDL_Window, &data.wrect); + + EnumDisplayMonitors(NULL, NULL, visibility_cb, (LPARAM)&data); + + if ( !data.result && recenter ) { + int new_x = 10; + int new_y = 10; + + if ( !data.first ) { + int primary_w = data.primary.right - data.primary.left; + int primary_h = data.primary.bottom - data.primary.top; + + new_x = data.primary.left + (primary_w - this->screen->w)/2; + new_y = data.primary.top + (primary_h - this->screen->h)/2; + } + DIB_SetWinPos(this, new_x, new_y); + } + return data.result; +} + +static int DIB_GetMonitorDPI(_THIS, int* xDpi, int *yDpi) +{ + HDC displayDC = CreateDC( "DISPLAY", NULL, NULL, NULL ); + int xdpi, ydpi; + + if (displayDC == NULL) { + return -1; + } + xdpi = GetDeviceCaps( displayDC, LOGPIXELSX ); + ydpi = GetDeviceCaps( displayDC, LOGPIXELSY ); + + DeleteDC(displayDC); + + /* sanity checks */ + if (xdpi < 20 || xdpi > 400 || ydpi < 20 || ydpi > 400) { + return -1; + } + + *xDpi = xdpi; + *yDpi = ydpi; + return 0; +} + + +typedef struct { + int first; + RECT wrect; + long bestArea; + RECT bestRect; + RECT primary; +} ProximityData; + +BOOL CALLBACK proximity_cb(HMONITOR hMonitor, + HDC hdcMonitor, + LPRECT mrect, + LPARAM dwData) +{ + ProximityData* data = (ProximityData*)dwData; + int x1, y1, x2, y2, area; + + x1 = mrect->left; + x2 = mrect->right; + y1 = mrect->top; + y2 = mrect->bottom; + + if (data->first) { + data->primary = mrect[0]; + } + + if (x1 < data->wrect.left) + x1 = data->wrect.left; + if (x2 > data->wrect.right) + x2 = data->wrect.right; + if (y1 < data->wrect.top) + y1 = data->wrect.top; + if (y2 > data->wrect.bottom) + y2 = data->wrect.bottom; + + if (x1 >= x2 || y1 >= y2) + return TRUE; + + area = (x2-x1)*(y2-y1); + if (data->first || area > data->bestArea) { + data->first = 0; + data->bestRect = mrect[0]; + data->bestArea = area; + } + return TRUE; +} + +static int DIB_GetMonitorRect(_THIS, SDL_Rect* rect) +{ + ProximityData data; + RECT* sr; + + data.first = 1; + GetWindowRect(SDL_Window, &data.wrect); + + EnumDisplayMonitors(NULL, NULL, proximity_cb, (LPARAM)&data); + + if (data.first) + return -1; + + sr = &data.bestRect; + + rect->x = sr->left; + rect->y = sr->top; + rect->w = sr->right - sr->left; + rect->h = sr->bottom - sr->top; + + return 0; +} + /* Stub in case DirectX isn't available */ #if !SDL_AUDIO_DRIVER_DSOUND void DX5_SoundFocus(HWND hwnd) diff --git a/distrib/sdl-1.2.15/src/video/x11/SDL_x11dyn.c b/distrib/sdl-1.2.15/src/video/x11/SDL_x11dyn.c index 7058add..7d4acbb 100644 --- a/distrib/sdl-1.2.15/src/video/x11/SDL_x11dyn.c +++ b/distrib/sdl-1.2.15/src/video/x11/SDL_x11dyn.c @@ -200,6 +200,7 @@ int SDL_X11_LoadSymbols(void) if (SDL_X11_HAVE_BASEXLIB) { /* all required symbols loaded. */ SDL_ClearError(); + XInitThreads(); } else { SDL_X11_UnloadSymbols(); /* in case something got loaded... */ rc = 0; diff --git a/distrib/sdl-1.2.15/src/video/x11/SDL_x11sym.h b/distrib/sdl-1.2.15/src/video/x11/SDL_x11sym.h index 4875b98..f9c7df3 100644 --- a/distrib/sdl-1.2.15/src/video/x11/SDL_x11sym.h +++ b/distrib/sdl-1.2.15/src/video/x11/SDL_x11sym.h @@ -31,6 +31,7 @@ SDL_X11_SYM(int,XChangeWindowAttributes,(Display* a,Window b,unsigned long c,XSe SDL_X11_SYM(Bool,XCheckTypedEvent,(Display* a,int b,XEvent* c),(a,b,c),return) SDL_X11_SYM(int,XClearWindow,(Display* a,Window b),(a,b),return) SDL_X11_SYM(int,XCloseDisplay,(Display* a),(a),return) +SDL_X11_SYM(int,XConfigureWindow,(Display* a,Window b,unsigned int c,XWindowChanges* d),(a,b,c,d),return) SDL_X11_SYM(Colormap,XCreateColormap,(Display* a,Window b,Visual* c,int d),(a,b,c,d),return) SDL_X11_SYM(Cursor,XCreatePixmapCursor,(Display* a,Pixmap b,Pixmap c,XColor* d,XColor* e,unsigned int f,unsigned int g),(a,b,c,d,e,f,g),return) SDL_X11_SYM(GC,XCreateGC,(Display* a,Drawable b,unsigned long c,XGCValues* d),(a,b,c,d),return) @@ -39,6 +40,11 @@ SDL_X11_SYM(Pixmap,XCreatePixmap,(Display* a,Drawable b,unsigned int c,unsigned SDL_X11_SYM(Pixmap,XCreatePixmapFromBitmapData,(Display* a,Drawable b,char* c,unsigned int d,unsigned int e,unsigned long f,unsigned long g,unsigned int h),(a,b,c,d,e,f,g,h),return) SDL_X11_SYM(Window,XCreateSimpleWindow,(Display* a,Window b,int c,int d,unsigned int e,unsigned int f,unsigned int g,unsigned long h,unsigned long i),(a,b,c,d,e,f,g,h,i),return) SDL_X11_SYM(Window,XCreateWindow,(Display* a,Window b,int c,int d,unsigned int e,unsigned int f,unsigned int g,int h,unsigned int i,Visual* j,unsigned long k,XSetWindowAttributes* l),(a,b,c,d,e,f,g,h,i,j,k,l),return) +SDL_X11_SYM(int,XDefaultScreen,(Display* a),(a),return) +SDL_X11_SYM(int,XDisplayWidth,(Display* a,int b),(a,b),return) +SDL_X11_SYM(int,XDisplayWidthMM,(Display* a, int b),(a, b),return) +SDL_X11_SYM(int,XDisplayHeight,(Display* a,int b),(a,b),return) +SDL_X11_SYM(int,XDisplayHeightMM,(Display* a, int b),(a, b),return) SDL_X11_SYM(int,XDefineCursor,(Display* a,Window b,Cursor c),(a,b,c),return) SDL_X11_SYM(int,XDeleteProperty,(Display* a,Window b,Atom c),(a,b,c),return) SDL_X11_SYM(int,XDestroyWindow,(Display* a,Window b),(a,b),return) @@ -54,6 +60,7 @@ SDL_X11_SYM(int,XFreeGC,(Display* a,GC b),(a,b),return) SDL_X11_SYM(int,XFreeModifiermap,(XModifierKeymap* a),(a),return) SDL_X11_SYM(int,XFreePixmap,(Display* a,Pixmap b),(a,b),return) SDL_X11_SYM(int,XGetErrorDatabaseText,(Display* a,_Xconst char* b,_Xconst char* c,_Xconst char* d,char* e,int f),(a,b,c,d,e,f),return) +SDL_X11_SYM(int,XGetGeometry,(Display* a,Drawable b,Window* c,int* d,int* e,unsigned int* f,unsigned int* g,unsigned int* h,unsigned int* i),(a,b,c,d,e,f,g,h,i),return) SDL_X11_SYM(XModifierKeymap*,XGetModifierMapping,(Display* a),(a),return) SDL_X11_SYM(int,XGetPointerControl,(Display* a,int* b,int* c,int* d),(a,b,c,d),return) SDL_X11_SYM(XVisualInfo*,XGetVisualInfo,(Display* a,long b,XVisualInfo* c,int* d),(a,b,c,d),return) @@ -62,6 +69,7 @@ SDL_X11_SYM(Status,XGetWindowAttributes,(Display* a,Window b,XWindowAttributes* SDL_X11_SYM(int,XGrabKeyboard,(Display* a,Window b,Bool c,int d,int e,Time f),(a,b,c,d,e,f),return) SDL_X11_SYM(int,XGrabPointer,(Display* a,Window b,Bool c,unsigned int d,int e,int f,Window g,Cursor h,Time i),(a,b,c,d,e,f,g,h,i),return) SDL_X11_SYM(Status,XIconifyWindow,(Display* a,Window b,int c),(a,b,c),return) +SDL_X11_SYM(Status,XInitThreads,(void),(),return) SDL_X11_SYM(int,XInstallColormap,(Display* a,Colormap b),(a,b),return) SDL_X11_SYM(KeyCode,XKeysymToKeycode,(Display* a,KeySym b),(a,b),return) SDL_X11_SYM(Atom,XInternAtom,(Display* a,_Xconst char* b,Bool c),(a,b,c),return) @@ -82,6 +90,7 @@ SDL_X11_SYM(int,XPutImage,(Display* a,Drawable b,GC c,XImage* d,int e,int f,int SDL_X11_SYM(int,XQueryColors,(Display* a,Colormap b,XColor* c,int d),(a,b,c,d),return) SDL_X11_SYM(int,XQueryKeymap,(Display* a,char *b),(a,b),return) SDL_X11_SYM(Bool,XQueryPointer,(Display* a,Window b,Window* c,Window* d,int* e,int* f,int* g,int* h,unsigned int* i),(a,b,c,d,e,f,g,h,i),return) +SDL_X11_SYM(int,XQueryTree,(Display* a,Window b,Window* c,Window* d,Window** e,unsigned int* f),(a,b,c,d,e,f),return) SDL_X11_SYM(int,XRaiseWindow,(Display* a,Window b),(a,b),return) SDL_X11_SYM(int,XReparentWindow,(Display* a,Window b,Window c,int d,int e),(a,b,c,d,e),return) SDL_X11_SYM(int,XResetScreenSaver,(Display* a),(a),return) @@ -124,6 +133,7 @@ SDL_X11_SYM(void,_XSend,(Display* a,_Xconst char* b,long c),(a,b,c),) SDL_X11_SYM(Status,_XReply,(Display* a,xReply* b,int c,Bool d),(a,b,c,d),return) SDL_X11_SYM(unsigned long,_XSetLastRequestRead,(Display* a,xGenericReply* b),(a,b),return) SDL_X11_SYM(SDL_X11_XSynchronizeRetType,XSynchronize,(Display* a,Bool b),(a,b),return) +SDL_X11_SYM(int,XTranslateCoordinates,(Display* a,Window b,Window c,int d,int e,int* f,int* g,Window* h),(a,b,c,d,e,f,g,h),return) SDL_X11_SYM(SDL_X11_XESetWireToEventRetType,XESetWireToEvent,(Display* a,int b,SDL_X11_XESetWireToEventRetType c),(a,b,c),return) SDL_X11_SYM(SDL_X11_XESetEventToWireRetType,XESetEventToWire,(Display* a,int b,SDL_X11_XESetEventToWireRetType c),(a,b,c),return) SDL_X11_SYM(XExtensionErrorHandler,XSetExtensionErrorHandler,(XExtensionErrorHandler a),(a),return) diff --git a/distrib/sdl-1.2.15/src/video/x11/SDL_x11video.c b/distrib/sdl-1.2.15/src/video/x11/SDL_x11video.c index f7d8073..6d24422 100644 --- a/distrib/sdl-1.2.15/src/video/x11/SDL_x11video.c +++ b/distrib/sdl-1.2.15/src/video/x11/SDL_x11video.c @@ -68,6 +68,8 @@ static int X11_SetColors(_THIS, int firstcolor, int ncolors, static int X11_SetGammaRamp(_THIS, Uint16 *ramp); static void X11_VideoQuit(_THIS); +int X11_wmXAdjust; +int X11_wmYAdjust; /* X11 driver bootstrap functions */ @@ -164,6 +166,11 @@ static SDL_VideoDevice *X11_CreateDevice(int devindex) device->SetIcon = X11_SetIcon; device->IconifyWindow = X11_IconifyWindow; device->GrabInput = X11_GrabInput; + device->GetWindowPos = X11_GetWindowPos; + device->SetWindowPos = X11_SetWindowPos; + device->IsWindowVisible = X11_IsWindowVisible; + device->GetMonitorDPI = X11_GetMonitorDPI; + device->GetMonitorRect = X11_GetMonitorRect; device->GetWMInfo = X11_GetWMInfo; device->FreeWMCursor = X11_FreeWMCursor; device->CreateWMCursor = X11_CreateWMCursor; @@ -350,7 +357,9 @@ static void create_aux_windows(_THIS) xattr.colormap = SDL_XColorMap; FSwindow = XCreateWindow(SDL_Display, SDL_Root, - x, y, 32, 32, 0, + x + X11_wmXAdjust, + y + X11_wmYAdjust, + 32, 32, 0, this->hidden->depth, InputOutput, SDL_Visual, CWOverrideRedirect | CWBackPixel | CWBorderPixel | CWColormap, diff --git a/distrib/sdl-1.2.15/src/video/x11/SDL_x11video.h b/distrib/sdl-1.2.15/src/video/x11/SDL_x11video.h index f347560..18cf497 100644 --- a/distrib/sdl-1.2.15/src/video/x11/SDL_x11video.h +++ b/distrib/sdl-1.2.15/src/video/x11/SDL_x11video.h @@ -156,6 +156,9 @@ struct SDL_PrivateVideoData { int allow_screensaver; }; +extern int X11_wmXAdjust; +extern int X11_wmYAdjust; + /* Old variable names */ #define local_X11 (this->hidden->local_X11) #define SDL_Display (this->hidden->X11_Display) diff --git a/distrib/sdl-1.2.15/src/video/x11/SDL_x11wm.c b/distrib/sdl-1.2.15/src/video/x11/SDL_x11wm.c index 14c816b..2fd59e9 100644 --- a/distrib/sdl-1.2.15/src/video/x11/SDL_x11wm.c +++ b/distrib/sdl-1.2.15/src/video/x11/SDL_x11wm.c @@ -325,6 +325,147 @@ int X11_IconifyWindow(_THIS) return(result); } +#if 0 +#define D(...) printf(__VA_ARGS__) +#define E(...) D(__VA_ARGS__) +#else +#define D(...) ((void)0) +#define E(...) ((void)0) +#endif + +static void set_window_pos_nolock(_THIS, int x, int y) +{ + int xNew, yNew; + Window child; + int xAdjust = X11_wmXAdjust; + int yAdjust = X11_wmYAdjust; + + /* don't do anything in full-screen mode, because the FSwindow is used + * instead of the WMwindow, which will make the adjustment go wild + */ + if (this->screen->flags & SDL_FULLSCREEN) + return; + + /* this code is tricky because some window managers, but not all, + * will translate the final window position by a given offset + * corresponding to the frame decoration. + * + * so we first try to move the window, get the position that the + * window manager has set, and if they are different, re-position the + * window again with an adjustment. + * + * this causes a slight flicker since the window 'jumps' very + * quickly from one position to the other. + */ + + D("%s: move to [%d,%d] adjusted to [%d,%d]\n", __FUNCTION__, + x, y, x+xAdjust, y+yAdjust); + XMoveWindow(SDL_Display, WMwindow, x + xAdjust, y + yAdjust); + XSync(SDL_Display, True); + XTranslateCoordinates( SDL_Display, WMwindow, SDL_Root, 0, 0, &xNew, &yNew, &child ); + if (xNew != x || yNew != y) { + X11_wmXAdjust = xAdjust = x - xNew; + X11_wmYAdjust = yAdjust = y - yNew; + D("%s: read pos [%d,%d], recomputing adjust=[%d,%d] moving to [%d,%d]\n", + __FUNCTION__, xNew, yNew, xAdjust, yAdjust, x+xAdjust, y+yAdjust); + XMoveWindow(SDL_Display, WMwindow, x + xAdjust, y + yAdjust ); + } + XSync(SDL_Display, False); +} + +/* Set window position */ +void X11_SetWindowPos(_THIS, int x, int y) +{ + SDL_Lock_EventThread(); + set_window_pos_nolock(this, x, y); + SDL_Unlock_EventThread(); +} + +/* Get window position */ +void X11_GetWindowPos(_THIS, int *px, int *py) +{ + /* in full-screen mode, you can't move the window */ + if (this->screen->flags & SDL_FULLSCREEN) { + *px = *py = 0; + return; + } + + + SDL_Lock_EventThread(); + { + Window child; + + XTranslateCoordinates( SDL_Display, WMwindow, SDL_Root, 0, 0, px, py, &child ); + } + SDL_Unlock_EventThread(); +} + +static int +is_window_visible(_THIS, int screen_x, int screen_y, int screen_w, int screen_h ) +{ + XWindowAttributes attr; + int x, y; + Window child; + + XGetWindowAttributes( SDL_Display, WMwindow, &attr ); + XTranslateCoordinates( SDL_Display, WMwindow, SDL_Root, 0, 0, &x, &y, &child ); + + return ( x >= screen_x && x + attr.width <= screen_x + screen_w && + y >= screen_y && y + attr.height <= screen_y + screen_h ); +} + +int X11_IsWindowVisible(_THIS, int recenter) +{ + int result = 0; + XWindowAttributes attr; + int screen_w, screen_h; + + SDL_Lock_EventThread(); + XGetWindowAttributes( SDL_Display, SDL_Root, &attr ); + screen_w = attr.width; + screen_h = attr.height; + +#if SDL_VIDEO_DRIVER_X11_XINERAMA + if (use_xinerama) { + SDL_NAME(XineramaScreenInfo) *xinerama; + int i, screens; + + xinerama = SDL_NAME(XineramaQueryScreens)(SDL_Display, &screens); + for (i = 0; i < screens; i++) { + if ( is_window_visible( this, + xinerama[i].x_org, xinerama[i].y_org, + xinerama[i].width, xinerama[i].height ) ) + { + result = 1; + break; + } + } + + if ( !result && recenter ) { + set_window_pos_nolock(this, + xinerama[0].x_org + (xinerama[0].width - this->screen->w)/2, + xinerama[0].y_org + (xinerama[0].height - this->screen->h)/2 ); + } + XFree(xinerama); + goto Exit; + } +#endif + if ( is_window_visible( this, 0, 0, screen_w, screen_h ) ) { + result = 1; + } + + if ( !result && recenter ) { + set_window_pos_nolock( this, + (screen_w - this->screen->w)/2, + (screen_h - this->screen->h)/2 ); + } +#ifdef SDL_VIDEO_DRIVER_X11_XINERAMA +Exit: +#endif + SDL_Unlock_EventThread(); + return result; +} + SDL_GrabMode X11_GrabInputNoLock(_THIS, SDL_GrabMode mode) { int result; @@ -387,6 +528,51 @@ SDL_GrabMode X11_GrabInput(_THIS, SDL_GrabMode mode) return(mode); } +#define MM_PER_INCH 25.4 + +int +X11_GetMonitorDPI(_THIS, int *px_dpi, int *py_dpi) +{ + Display* display = SDL_Display; + int screen = XDefaultScreen(display); + int xdpi, ydpi; + + int width = XDisplayWidth(display, screen); + int width_mm = XDisplayWidthMM(display, screen); + int height = XDisplayHeight(display, screen); + int height_mm = XDisplayHeightMM(display, screen); + + if (width_mm <= 0 || height_mm <= 0) { + return -1; + } + + xdpi = (int)(width * MM_PER_INCH / width_mm + 0.5); + ydpi = (int)(height * MM_PER_INCH / height_mm + 0.5); + + if (xdpi < 20 || xdpi > 400 || ydpi < 20 || ydpi > 400) { + return -1; + } + + *px_dpi = xdpi; + *py_dpi = ydpi; + + return 0; +} + +int +X11_GetMonitorRect(_THIS, SDL_Rect *rect) +{ + Display* display = SDL_Display; + int screen = XDefaultScreen(display); + + rect->x = 0; + rect->y = 0; + rect->w = XDisplayWidth(display, screen); + rect->h = XDisplayHeight(display, screen); + + return 0; +} + /* If 'info' is the right version, this function fills it and returns 1. Otherwise, in case of a version mismatch, it returns -1. */ diff --git a/distrib/sdl-1.2.15/src/video/x11/SDL_x11wm_c.h b/distrib/sdl-1.2.15/src/video/x11/SDL_x11wm_c.h index f85477b..c0f938b 100644 --- a/distrib/sdl-1.2.15/src/video/x11/SDL_x11wm_c.h +++ b/distrib/sdl-1.2.15/src/video/x11/SDL_x11wm_c.h @@ -31,4 +31,8 @@ extern int X11_IconifyWindow(_THIS); extern SDL_GrabMode X11_GrabInputNoLock(_THIS, SDL_GrabMode mode); extern SDL_GrabMode X11_GrabInput(_THIS, SDL_GrabMode mode); extern int X11_GetWMInfo(_THIS, SDL_SysWMinfo *info); - +extern void X11_GetWindowPos(_THIS, int *px, int *py); +extern void X11_SetWindowPos(_THIS, int x, int y); +extern int X11_IsWindowVisible(_THIS, int recenter); +extern int X11_GetMonitorDPI(_THIS, int* xdpi, int *ydpi); +extern int X11_GetMonitorRect(_THIS, SDL_Rect *rect); |