Started to merge @ZobyTwo cmake branch

CMakeLists.txt

@@ -0,0 +1,196 @@
+cmake_minimum_required(VERSION 2.8.7)
+
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_SOURCE_DIR}/CMakeModules)
+
+#this block wil fix install prefixes to install everything in a subdirectory
+#of cmake_binary_dir if we are on windows/android to make packaging more easy
+if(NOT CMAKE_TOOLCHAIN_FILE)
+  if(WIN32)
+    set(CMAKE_INSTALL_PREFIX "${CMAKE_BINARY_DIR}/install" CACHE PATH "Install directory")
+  else()
+    set(CMAKE_INSTALL_PREFIX "/usr/local" CACHE PATH "Install directory")
+  endif()
+else() #we are cross-compiling (psp/android)
+  #Android: set output folder for platform/android to pick up
+  set(LIBRARY_OUTPUT_PATH_ROOT ${CMAKE_BINARY_DIR} CACHE PATH "library output root")
+  set(CMAKE_INSTALL_PREFIX "${CMAKE_BINARY_DIR}/install" CACHE PATH "Install directory")
+endif()
+
+#set available build types (debug/release)
+set(CMAKE_CONFIGURATION_TYPES "Debug;Release" CACHE STRING "Configs" FORCE)
+if(DEFINED CMAKE_BUILD_TYPE)
+  set_property( CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS ${CMAKE_CONFIGURATION_TYPES} )
+endif()
+
+set(EXECUTABLE_OUTPUT_PATH "${CMAKE_BINARY_DIR}/bin" CACHE PATH "Application output directory")
+
+
+project(wagic CXX C)
+#todo: somehow determine wagics version
+set(WAGIC_VERSION "0.19")
+
+#add standard paths to search for libraries. borrowed from opencv
+if(UNIX AND NOT ANDROID)
+  if(X86_64 OR CMAKE_SIZEOF_VOID_P EQUAL 8)
+    if(EXISTS /lib64)
+      list(APPEND CMAKE_LIBRARY_PATH /lib64)
+    else()
+      list(APPEND CMAKE_LIBRARY_PATH /lib)
+    endif()
+    if(EXISTS /usr/lib64)
+      list(APPEND CMAKE_LIBRARY_PATH /usr/lib64)
+    else()
+      list(APPEND CMAKE_LIBRARY_PATH /usr/lib)
+    endif()
+  elseif(X86 OR CMAKE_SIZEOF_VOID_P EQUAL 4)
+    if(EXISTS /lib32)
+      list(APPEND CMAKE_LIBRARY_PATH /lib32)
+    else()
+      list(APPEND CMAKE_LIBRARY_PATH /lib)
+    endif()
+    if(EXISTS /usr/lib32)
+      list(APPEND CMAKE_LIBRARY_PATH /usr/lib32)
+    else()
+      list(APPEND CMAKE_LIBRARY_PATH /usr/lib)
+    endif()
+  endif()
+endif()
+
+if(ANDROID OR PSP)
+    #to allow finding of pathes/headers/libs within the source tree
+    #even if only search for target platform libs
+    set(CMAKE_FIND_ROOT_PATH ${CMAKE_SOURCE_DIR} ${CMAKE_FIND_ROOT_PATH})
+endif()
+
+#also borrowed from opencv
+if(MINGW)
+  if(EXISTS /mingw)
+      list(APPEND CMAKE_INCLUDE_PATH /mingw)
+  endif()
+  if(EXISTS /mingw32)
+      list(APPEND CMAKE_INCLUDE_PATH /mingw32)
+  endif()
+  if(EXISTS /mingw64)
+      list(APPEND CMAKE_INCLUDE_PATH /mingw64)
+  endif()
+endif()
+
+include(utils)
+
+#select the target backend
+if(PSP)
+    WAGIC_OPTION(backend_psp         "build for psp"          ON)
+endif()
+if(WIN32 OR ANDROID OR UNIX)
+    WAGIC_OPTION(backend_sdl         "build for sdl"          (WIN32 OR ANDROID))
+endif()
+if(UNIX AND NOT ANDROID)
+    WAGIC_OPTION(backend_qt_console  "build qt-console version with testsuit" ON)
+    WAGIC_OPTION(backend_qt_widget   "build qt-widget version"                OFF)
+endif()
+
+#third party build options
+WAGIC_OPTION(BUILD_ZLIB    "build zlib from source"    OFF)
+WAGIC_OPTION(BUILD_JPEG    "build jpeg from source"    (WIN32 OR APPLE OR PSP OR ANDROID))
+WAGIC_OPTION(BUILD_PNG     "build png from source"     (WIN32 OR APPLE OR PSP OR ANDROID))
+WAGIC_OPTION(BUILD_UNZIP   "build unzip from source"   ON)
+WAGIC_OPTION(BUILD_TINYXML "build tinyxml from source" (WIN32 OR APPLE OR PSP OR ANDROID))
+WAGIC_OPTION(BUILD_ZIPFS   "build zipfs from source"   ON)
+
+#project options
+if(ANDROID)
+    WAGIC_OPTION(BUILD_ANDROID_PACKAGE "put the compiled code in an android package" ON)
+endif()
+
+
+if(ANDROID)
+    set(LIBRARY_OUTPUT_PATH        "${CMAKE_BINARY_DIR}/lib/${ANDROID_NDK_ABI_NAME}")
+    set(3P_LIBRARY_OUTPUT_PATH     "${CMAKE_BINARY_DIR}/3rdparty/lib/${ANDROID_NDK_ABI_NAME}")
+    set(WAGIC_LIB_INSTALL_PATH     sdk/native/libs/${ANDROID_NDK_ABI_NAME})
+    set(WAGIC_3P_LIB_INSTALL_PATH  sdk/native/3rdparty/libs/${ANDROID_NDK_ABI_NAME})
+    set(WAGIC_CONFIG_INSTALL_PATH  sdk/native/jni)
+    set(WAGIC_INCLUDE_INSTALL_PATH sdk/native/jni/include)
+    set(EXECUTABLE_OUTPUT_PATH     "${CMAKE_BINARY_DIR}/package/bin")
+else()
+    set(LIBRARY_OUTPUT_PATH        "${CMAKE_BINARY_DIR}/lib")
+    set(3P_LIBRARY_OUTPUT_PATH     "${OpenCV_BINARY_DIR}/3rdparty/lib${LIB_SUFFIX}")
+    set(WAGIC_LIB_INSTALL_PATH     lib${LIB_SUFFIX})
+    set(WAGIC_3P_LIB_INSTALL_PATH  share/wagic/3rdparty/${OPENCV_LIB_INSTALL_PATH})
+    set(WAGIC_INCLUDE_INSTALL_PATH "include")
+    set(WAGIC_CONFIG_INSTALL_PATH  share/wagic)
+endif()
+
+set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/${WAGIC_LIB_INSTALL_PATH}")
+set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
+
+#if no build type is specified, we assume debug
+if(CMAKE_GENERATOR MATCHES "Makefiles|Ninja" AND "${CMAKE_BUILD_TYPE}" STREQUAL "")
+  set(CMAKE_BUILD_TYPE Debug)
+endif()
+
+include(FindOrBuild)
+
+#set platform dependend configurations
+if(PSP)
+    FindOrBuildPSPSDK()
+    include(platforms/psp/configure.cmake)
+elseif(WIN32)
+    include(platforms/win/configure.cmake)
+elseif(UNIX)
+    include(platforms/unix/configure.cmake)
+elseif(ANDROID)
+    include(platforms/android/configure.cmake)
+endif()
+
+#set backend dependend configurations
+if(backend_qt_console OR backend_qt_widget)
+    add_definitions(-DQT_CONFIG)
+    if(backend_qt_console)
+        add_definitions(-DTESTSUITE -D_DEBUG)
+        add_definitions(-DCONSOLE_CONFIG -DCAPTURE_STDERR)
+    endif()
+elseif(backend_sdl)
+    add_definitions(-DSDL_CONFIG)
+endif()
+
+# find or build 3rd party libraries
+
+FindOrBuildOpenGL()
+FindOrBuildTinyXML()
+FindOrBuildZipFS()
+FindOrBuildUNZIP()
+FindOrBuildPNG()
+FindOrBuildJPEG()
+FindOrBuildBoost()
+if(PSP)
+    FindOrBuildGIF()
+endif()
+if(ANDROID)
+    FindOrBuildOpenSL()
+endif()
+if(backend_sdl)
+    FindOrBuildSDL2()
+endif()
+if(backend_psp)
+    FindOrBuildFreetype()
+    FindOrBuildHgeTools()
+    FindOrBuildMikMod()
+endif()
+if(backend_qt_console OR backend_qt_widget)
+    FindOrBuildQt()
+endif()
+if(ANDROID)
+    include(DetectAndroidSDK)
+endif()
+
+if(BUILD_ANDROID_PACKAGE)
+    find_package(Ant REQUIRED)
+endif()
+
+#add jge and mtg projects
+add_subdirectory(JGE)
+add_subdirectory(projects/mtg)
+
+if(BUILD_ANDROID_PACKAGE)
+  add_subdirectory(platforms/android/package)
+endif()

CMakeModules/DetectAndroidSDK.cmake

@@ -0,0 +1,373 @@
+if(EXISTS "${ANDROID_EXECUTABLE}")
+  set(ANDROID_SDK_DETECT_QUIET TRUE)
+endif()
+
+file(TO_CMAKE_PATH "$ENV{ProgramFiles}" ProgramFiles_ENV_PATH)
+file(TO_CMAKE_PATH "$ENV{HOME}" HOME_ENV_PATH)
+
+if(CMAKE_HOST_WIN32)
+  set(ANDROID_SDK_OS windows)
+elseif(CMAKE_HOST_APPLE)
+  set(ANDROID_SDK_OS macosx)
+else()
+  set(ANDROID_SDK_OS linux)
+endif()
+
+#find android SDK: search in ANDROID_SDK first
+find_host_program(ANDROID_EXECUTABLE
+  NAMES android.bat android
+  PATH_SUFFIXES tools
+  PATHS
+    ENV ANDROID_SDK
+  DOC "Android SDK location"
+  NO_DEFAULT_PATH
+  )
+
+# Now search default paths
+find_host_program(ANDROID_EXECUTABLE
+  NAMES android.bat android
+  PATH_SUFFIXES android-sdk-${ANDROID_SDK_OS}/tools
+                android-sdk-${ANDROID_SDK_OS}_x86/tools
+                android-sdk-${ANDROID_SDK_OS}_86/tools
+                android-sdk/tools
+  PATHS /opt
+        "${HOME_ENV_PATH}/NVPACK"
+        "$ENV{SystemDrive}/NVPACK"
+        "${ProgramFiles_ENV_PATH}/Android"
+  DOC "Android SDK location"
+  )
+
+if(ANDROID_EXECUTABLE)
+  if(NOT ANDROID_SDK_DETECT_QUIET)
+    message(STATUS "Found android tool: ${ANDROID_EXECUTABLE}")
+  endif()
+
+  get_filename_component(ANDROID_SDK_TOOLS_PATH "${ANDROID_EXECUTABLE}" PATH)
+
+  #read source.properties
+  if(EXISTS "${ANDROID_SDK_TOOLS_PATH}/source.properties")
+    file(STRINGS "${ANDROID_SDK_TOOLS_PATH}/source.properties" ANDROID_SDK_TOOLS_SOURCE_PROPERTIES_LINES REGEX "^[ ]*[^#].*$")
+    foreach(line ${ANDROID_SDK_TOOLS_SOURCE_PROPERTIES_LINES})
+      string(REPLACE "\\:" ":" line ${line})
+      string(REPLACE "=" ";" line ${line})
+      list(GET line 0 line_name)
+      list(GET line 1 line_value)
+      string(REPLACE "." "_" line_name ${line_name})
+      SET(ANDROID_TOOLS_${line_name} "${line_value}" CACHE INTERNAL "from ${ANDROID_SDK_TOOLS_PATH}/source.properties")
+      MARK_AS_ADVANCED(ANDROID_TOOLS_${line_name})
+    endforeach()
+  endif()
+
+  #fix missing revision (SDK tools before r9 don't set revision number correctly)
+  if(NOT ANDROID_TOOLS_Pkg_Revision)
+    SET(ANDROID_TOOLS_Pkg_Revision "Unknown" CACHE INTERNAL "")
+    MARK_AS_ADVANCED(ANDROID_TOOLS_Pkg_Revision)
+  endif()
+
+  #fix missing description
+  if(NOT ANDROID_TOOLS_Pkg_Desc)
+    SET(ANDROID_TOOLS_Pkg_Desc "Android SDK Tools, revision ${ANDROID_TOOLS_Pkg_Revision}." CACHE INTERNAL "")
+    MARK_AS_ADVANCED(ANDROID_TOOLS_Pkg_Desc)
+  endif()
+
+  #warn about outdated SDK
+  if(NOT ANDROID_TOOLS_Pkg_Revision GREATER 13)
+    SET(ANDROID_TOOLS_Pkg_Desc "${ANDROID_TOOLS_Pkg_Desc} It is recommended to update your SDK tools to revision 14 or newer." CACHE INTERNAL "")
+  endif()
+
+  if(ANDROID_TOOLS_Pkg_Revision GREATER 13)
+    SET(ANDROID_PROJECT_PROPERTIES_FILE project.properties)
+    SET(ANDROID_ANT_PROPERTIES_FILE ant.properties)
+  else()
+    SET(ANDROID_PROJECT_PROPERTIES_FILE default.properties)
+    SET(ANDROID_ANT_PROPERTIES_FILE build.properties)
+  endif()
+
+  set(ANDROID_MANIFEST_FILE AndroidManifest.xml)
+  set(ANDROID_LIB_PROJECT_FILES build.xml local.properties proguard-project.txt ${ANDROID_PROJECT_PROPERTIES_FILE})
+  set(ANDROID_PROJECT_FILES ${ANDROID_LIB_PROJECT_FILES})
+
+  #get installed targets
+  if(ANDROID_TOOLS_Pkg_Revision GREATER 11)
+    execute_process(COMMAND ${ANDROID_EXECUTABLE} list target -c
+      RESULT_VARIABLE ANDROID_PROCESS
+      OUTPUT_VARIABLE ANDROID_SDK_TARGETS
+      ERROR_VARIABLE ANDROID_PROCESS_ERRORS
+      OUTPUT_STRIP_TRAILING_WHITESPACE
+      )
+    string(REGEX MATCHALL "[^\n]+" ANDROID_SDK_TARGETS "${ANDROID_SDK_TARGETS}")
+  else()
+    #old SDKs (r11 and older) don't provide compact list
+    execute_process(COMMAND ${ANDROID_EXECUTABLE} list target
+      RESULT_VARIABLE ANDROID_PROCESS
+      OUTPUT_VARIABLE ANDROID_SDK_TARGETS_FULL
+      ERROR_VARIABLE ANDROID_PROCESS_ERRORS
+      OUTPUT_STRIP_TRAILING_WHITESPACE
+      )
+    string(REGEX MATCHALL "(^|\n)id: [0-9]+ or \"([^\n]+[0-9+])\"(\n|$)" ANDROID_SDK_TARGETS_FULL "${ANDROID_SDK_TARGETS_FULL}")
+
+    SET(ANDROID_SDK_TARGETS "")
+    if(ANDROID_PROCESS EQUAL 0)
+      foreach(line ${ANDROID_SDK_TARGETS_FULL})
+        string(REGEX REPLACE "(^|\n)id: [0-9]+ or \"([^\n]+[0-9+])\"(\n|$)" "\\2" line "${line}")
+        list(APPEND ANDROID_SDK_TARGETS "${line}")
+      endforeach()
+    endif()
+  endif()
+
+  if(NOT ANDROID_PROCESS EQUAL 0)
+    message(ERROR "Failed to get list of installed Android targets.")
+    set(ANDROID_EXECUTABLE "ANDROID_EXECUTABLE-NOTFOUND")
+  endif()
+
+  # clear ANDROID_SDK_TARGET if no target is provided by user
+  if(NOT ANDROID_SDK_TARGET)
+    set(ANDROID_SDK_TARGET "" CACHE STRING "Android SDK target for the Wagic Java API and samples")
+  endif()
+  if(ANDROID_SDK_TARGETS)
+    set_property( CACHE ANDROID_SDK_TARGET PROPERTY STRINGS ${ANDROID_SDK_TARGETS} )
+  endif()
+endif(ANDROID_EXECUTABLE)
+
+# finds minimal installed SDK target compatible with provided names or API levels
+# usage:
+#   get_compatible_android_api_level(VARIABLE [level1] [level2] ...)
+macro(android_get_compatible_target VAR)
+  set(${VAR} "${VAR}-NOTFOUND")
+  if(ANDROID_SDK_TARGETS)
+    list(GET ANDROID_SDK_TARGETS 0 __lvl)
+    string(REGEX MATCH "[0-9]+$" __lvl "${__lvl}")
+
+    #find minimal level mathing to all provided levels
+    foreach(lvl ${ARGN})
+      string(REGEX MATCH "[0-9]+$" __level "${lvl}")
+      if(__level GREATER __lvl)
+        set(__lvl ${__level})
+      endif()
+    endforeach()
+
+    #search for compatible levels
+    foreach(lvl ${ANDROID_SDK_TARGETS})
+      string(REGEX MATCH "[0-9]+$" __level "${lvl}")
+      if(__level EQUAL __lvl)
+        #look for exact match
+        foreach(usrlvl ${ARGN})
+          if("${usrlvl}" STREQUAL "${lvl}")
+            set(${VAR} "${lvl}")
+            break()
+          endif()
+        endforeach()
+        if("${${VAR}}" STREQUAL "${lvl}")
+          break() #exact match was found
+        elseif(NOT ${VAR})
+          set(${VAR} "${lvl}")
+        endif()
+      elseif(__level GREATER __lvl)
+        if(NOT ${VAR})
+          set(${VAR} "${lvl}")
+        endif()
+        break()
+      endif()
+    endforeach()
+
+    unset(__lvl)
+    unset(__level)
+  endif()
+endmacro()
+
+unset(__android_project_chain CACHE)
+
+# add_android_project(target_name ${path} NATIVE_DEPS opencv_core LIBRARY_DEPS ${Wagic_BINARY_DIR} SDK_TARGET 11)
+macro(add_android_project target path)
+  # parse arguments
+  set(android_proj_arglist NATIVE_DEPS LIBRARY_DEPS SDK_TARGET IGNORE_JAVA IGNORE_MANIFEST)
+  set(__varname "android_proj_")
+  foreach(v ${android_proj_arglist})
+    set(${__varname}${v} "")
+  endforeach()
+  foreach(arg ${ARGN})
+    set(__var "${__varname}")
+    foreach(v ${android_proj_arglist})
+      if("${v}" STREQUAL "${arg}")
+        set(__varname "android_proj_${v}")
+        break()
+      endif()
+    endforeach()
+    if(__var STREQUAL __varname)
+      list(APPEND ${__var} "${arg}")
+    endif()
+  endforeach()
+
+  # get compatible SDK target
+  android_get_compatible_target(android_proj_sdk_target ${ANDROID_NATIVE_API_LEVEL} ${android_proj_SDK_TARGET})
+
+  if(NOT android_proj_sdk_target)
+    message(WARNING "Can not find any SDK target compatible with: ${ANDROID_NATIVE_API_LEVEL} ${android_proj_SDK_TARGET}
+                     The project ${target} will not be build")
+  endif()
+
+  # check native dependencies
+  if(android_proj_IGNORE_JAVA)
+    ocv_check_dependencies(${android_proj_NATIVE_DEPS})
+  else()
+    ocv_check_dependencies(${android_proj_NATIVE_DEPS} opencv_java)
+  endif()
+
+  if(EXISTS "${path}/jni/Android.mk" )
+    # find if native_app_glue is used
+    file(STRINGS "${path}/jni/Android.mk" NATIVE_APP_GLUE REGEX ".*(call import-module,android/native_app_glue)" )
+    if(NATIVE_APP_GLUE)
+      if(ANDROID_NATIVE_API_LEVEL LESS 9 OR NOT EXISTS "${ANDROID_NDK}/sources/android/native_app_glue")
+        set(OCV_DEPENDENCIES_FOUND FALSE)
+      endif()
+    endif()
+  endif()
+
+  if(OCV_DEPENDENCIES_FOUND AND android_proj_sdk_target AND ANDROID_EXECUTABLE AND ANT_EXECUTABLE AND ANDROID_TOOLS_Pkg_Revision GREATER 13 AND EXISTS "${path}/${ANDROID_MANIFEST_FILE}")
+
+    project(${target})
+    set(android_proj_bin_dir "${CMAKE_CURRENT_BINARY_DIR}/.build")
+
+    # get project sources
+    file(GLOB_RECURSE android_proj_files RELATIVE "${path}" "${path}/res/*" "${path}/src/*")
+
+    if(NOT android_proj_IGNORE_MANIFEST)
+      list(APPEND android_proj_files ${ANDROID_MANIFEST_FILE})
+    endif()
+
+    # copy sources out from the build tree
+    set(android_proj_file_deps "")
+    foreach(f ${android_proj_files})
+      add_custom_command(
+        OUTPUT "${android_proj_bin_dir}/${f}"
+        COMMAND ${CMAKE_COMMAND} -E copy "${path}/${f}" "${android_proj_bin_dir}/${f}"
+        MAIN_DEPENDENCY "${path}/${f}"
+        COMMENT "Copying ${f}")
+      list(APPEND android_proj_file_deps "${path}/${f}" "${android_proj_bin_dir}/${f}")
+    endforeach()
+
+    set(android_proj_lib_deps_commands "")
+    set(android_proj_target_files ${ANDROID_PROJECT_FILES})
+    ocv_list_add_prefix(android_proj_target_files "${android_proj_bin_dir}/")
+
+    # process Android library dependencies
+    foreach(dep ${android_proj_LIBRARY_DEPS})
+      file(RELATIVE_PATH __dep "${android_proj_bin_dir}" "${dep}")
+      list(APPEND android_proj_lib_deps_commands
+        COMMAND ${ANDROID_EXECUTABLE} --silent update project --path "${android_proj_bin_dir}" --library "${__dep}")
+    endforeach()
+
+    # fix Android project
+    add_custom_command(
+        OUTPUT ${android_proj_target_files}
+        COMMAND ${CMAKE_COMMAND} -E remove ${android_proj_target_files}
+        COMMAND ${ANDROID_EXECUTABLE} --silent update project --path "${android_proj_bin_dir}" --target "${android_proj_sdk_target}" --name "${target}"
+        ${android_proj_lib_deps_commands}
+        MAIN_DEPENDENCY "${android_proj_bin_dir}/${ANDROID_MANIFEST_FILE}"
+        DEPENDS "${path}/${ANDROID_MANIFEST_FILE}"
+        COMMENT "Updating Android project at ${path}. SDK target: ${android_proj_sdk_target}"
+        )
+
+    list(APPEND android_proj_file_deps ${android_proj_target_files})
+
+    # build native part
+    file(GLOB_RECURSE android_proj_jni_files "${path}/jni/*.c" "${path}/jni/*.h" "${path}/jni/*.cpp" "${path}/jni/*.hpp")
+    ocv_list_filterout(android_proj_jni_files "\\\\.svn")
+
+    if(android_proj_jni_files AND EXISTS ${path}/jni/Android.mk AND NOT DEFINED JNI_LIB_NAME)
+      # find local module name in Android.mk file to build native lib
+      file(STRINGS "${path}/jni/Android.mk" JNI_LIB_NAME REGEX "LOCAL_MODULE[ ]*:=[ ]*.*" )
+      string(REGEX REPLACE "LOCAL_MODULE[ ]*:=[ ]*([a-zA-Z_][a-zA-Z_0-9]*)[ ]*" "\\1" JNI_LIB_NAME "${JNI_LIB_NAME}")
+
+      if(JNI_LIB_NAME)
+        ocv_include_modules_recurse(${android_proj_NATIVE_DEPS})
+        ocv_include_directories("${path}/jni")
+
+        if(NATIVE_APP_GLUE)
+          include_directories(${ANDROID_NDK}/sources/android/native_app_glue)
+          list(APPEND android_proj_jni_files ${ANDROID_NDK}/sources/android/native_app_glue/android_native_app_glue.c)
+          ocv_warnings_disable(CMAKE_C_FLAGS -Wstrict-prototypes -Wunused-parameter -Wmissing-prototypes)
+          set(android_proj_NATIVE_DEPS ${android_proj_NATIVE_DEPS} android)
+        endif()
+
+        add_library(${JNI_LIB_NAME} MODULE ${android_proj_jni_files})
+        target_link_libraries(${JNI_LIB_NAME} ${OPENCV_LINKER_LIBS} ${android_proj_NATIVE_DEPS})
+
+        set_target_properties(${JNI_LIB_NAME} PROPERTIES
+            OUTPUT_NAME "${JNI_LIB_NAME}"
+            LIBRARY_OUTPUT_DIRECTORY "${android_proj_bin_dir}/libs/${ANDROID_NDK_ABI_NAME}"
+            )
+
+        get_target_property(android_proj_jni_location "${JNI_LIB_NAME}" LOCATION)
+        if (NOT (CMAKE_BUILD_TYPE MATCHES "debug"))
+            add_custom_command(TARGET ${JNI_LIB_NAME} POST_BUILD COMMAND ${CMAKE_STRIP} --strip-unneeded "${android_proj_jni_location}")
+        endif()
+      endif()
+    endif()
+
+    # build java part
+    if(android_proj_IGNORE_JAVA)
+      add_custom_command(
+         OUTPUT "${android_proj_bin_dir}/bin/${target}-debug.apk"
+         COMMAND ${ANT_EXECUTABLE} -q -noinput -k debug
+         COMMAND ${CMAKE_COMMAND} -E touch "${android_proj_bin_dir}/bin/${target}-debug.apk" # needed because ant does not update the timestamp of updated apk
+         WORKING_DIRECTORY "${android_proj_bin_dir}"
+         MAIN_DEPENDENCY "${android_proj_bin_dir}/${ANDROID_MANIFEST_FILE}"
+         DEPENDS ${android_proj_file_deps} ${JNI_LIB_NAME})
+    else()
+      add_custom_command(
+         OUTPUT "${android_proj_bin_dir}/bin/${target}-debug.apk"
+         COMMAND ${ANT_EXECUTABLE} -q -noinput -k debug
+         COMMAND ${CMAKE_COMMAND} -E touch "${android_proj_bin_dir}/bin/${target}-debug.apk" # needed because ant does not update the timestamp of updated apk
+         WORKING_DIRECTORY "${android_proj_bin_dir}"
+         MAIN_DEPENDENCY "${android_proj_bin_dir}/${ANDROID_MANIFEST_FILE}"
+         DEPENDS "${Wagic_BINARY_DIR}/bin/classes.jar.dephelper" opencv_java # as we are part of Wagic we can just force this dependency
+         DEPENDS ${android_proj_file_deps} ${JNI_LIB_NAME})
+    endif()
+
+    unset(JNI_LIB_NAME)
+
+    add_custom_target(${target} ALL SOURCES "${android_proj_bin_dir}/bin/${target}-debug.apk" )
+    if(NOT android_proj_IGNORE_JAVA)
+      add_dependencies(${target} opencv_java)
+    endif()
+    if(android_proj_native_deps)
+      add_dependencies(${target} ${android_proj_native_deps})
+    endif()
+
+    if(__android_project_chain)
+      add_dependencies(${target} ${__android_project_chain})
+    endif()
+    set(__android_project_chain ${target} CACHE INTERNAL "auxiliary variable used for Android progects chaining")
+
+    # put the final .apk to the Wagic's bin folder
+    add_custom_command(TARGET ${target} POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy "${android_proj_bin_dir}/bin/${target}-debug.apk" "${Wagic_BINARY_DIR}/bin/${target}.apk")
+    if(INSTALL_ANDROID_EXAMPLES AND "${target}" MATCHES "^example-")
+      #apk
+      install(FILES "${Wagic_BINARY_DIR}/bin/${target}.apk" DESTINATION "samples" COMPONENT main)
+      get_filename_component(sample_dir "${path}" NAME)
+      #java part
+      list(REMOVE_ITEM android_proj_files ${ANDROID_MANIFEST_FILE})
+      foreach(f ${android_proj_files} ${ANDROID_MANIFEST_FILE})
+        get_filename_component(install_subdir "${f}" PATH)
+        install(FILES "${android_proj_bin_dir}/${f}" DESTINATION "samples/${sample_dir}/${install_subdir}" COMPONENT main)
+      endforeach()
+      #jni part + eclipse files
+      file(GLOB_RECURSE jni_files RELATIVE "${path}" "${path}/jni/*" "${path}/.cproject")
+      ocv_list_filterout(jni_files "\\\\.svn")
+      foreach(f ${jni_files} ".classpath" ".project" ".settings/org.eclipse.jdt.core.prefs")
+        get_filename_component(install_subdir "${f}" PATH)
+        install(FILES "${path}/${f}" DESTINATION "samples/${sample_dir}/${install_subdir}" COMPONENT main)
+      endforeach()
+      #update proj
+      if(android_proj_lib_deps_commands)
+        set(inst_lib_opt " --library ../../sdk/java")
+      endif()
+      install(CODE "EXECUTE_PROCESS(COMMAND ${ANDROID_EXECUTABLE} --silent update project --path . --target \"${android_proj_sdk_target}\" --name \"${target}\" ${inst_lib_opt}
+                                    WORKING_DIRECTORY \"\$ENV{DESTDIR}\${CMAKE_INSTALL_PREFIX}/samples/${sample_dir}\"
+                                   )"  COMPONENT main)
+      #empty 'gen'
+      install(CODE "MAKE_DIRECTORY(\"\$ENV{DESTDIR}\${CMAKE_INSTALL_PREFIX}/samples/${sample_dir}/gen\")" COMPONENT main)
+    endif()
+  endif()
+endmacro() 

CMakeModules/FindAnt.cmake

@@ -0,0 +1,13 @@
+find_host_program(ANT_EXECUTABLE "ant")
+
+if(ANT_EXECUTABLE)
+    set(ANT_FOUND ON)
+else()
+    set(ANT_FOUND OFF)
+endif()
+
+
+INCLUDE(FindPackageHandleStandardArgs)
+
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(ANT REQUIRED_VARS ANT_EXECUTABLE)
+mark_as_advanced(ANT_EXECUTABLE ANT_FOUND)

CMakeModules/FindOpenSL.cmake

@@ -0,0 +1,29 @@
+# - Find OpenSL (actually OpenSLES)
+# Find the OpenSLES includes and libraries
+#
+#  OPENSL_INCLUDE_DIR - where to find dsound.h
+#  OPENSL_LIBRARIES   - List of libraries when using dsound.
+#  OPENSL_FOUND       - True if dsound found.
+
+if(OPENSL_INCLUDE_DIR)
+    # Already in cache, be silent
+    set(OPENSL_FIND_QUIETLY TRUE)
+endif(OPENSL_INCLUDE_DIR)
+
+find_path(OPENSL_INCLUDE_DIR SLES/OpenSLES.h)
+
+find_library(OPENSL_LIBRARY NAMES OpenSLES)
+
+# Handle the QUIETLY and REQUIRED arguments and set OPENSL_FOUND to TRUE if
+# all listed variables are TRUE.
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(OPENSL DEFAULT_MSG
+    OPENSL_INCLUDE_DIR OPENSL_LIBRARY)
+
+if(OPENSL_FOUND)
+    set(OPENSL_LIBRARIES ${OPENSL_LIBRARY})
+else(OPENSL_FOUND)
+    set(OPENSL_LIBRARIES)
+endif(OPENSL_FOUND)
+
+mark_as_advanced(OPENSL_INCLUDE_DIR OPENSL_LIBRARY) 

CMakeModules/FindOrBuild.cmake

@@ -0,0 +1,215 @@
+macro(FindOrBuildZipFS)
+    if(BUILD_ZIPFS)
+        add_subdirectory(
+            ${CMAKE_SOURCE_DIR}/thirdparty/zipFS 
+            ${CMAKE_BINARY_DIR}/thirdparty/zipFS)
+        set(ZIPFS_INCLUDE_DIR ${CMAKE_SOURCE_DIR}/thirdparty/zipFS)
+        set(ZIPFS_LIBRARY zipFS)
+    else()
+        message(WARNING "ZIPFS must get build")
+    endif()
+endmacro()
+
+macro(FindOrBuildTinyXML)
+    if(BUILD_TINYXML)
+        add_definitions(-DTIXML_USE_STL)
+        add_subdirectory(
+            ${CMAKE_SOURCE_DIR}/thirdparty/tinyxml
+            ${CMAKE_BINARY_DIR}/thirdparty/tinyxml)
+        set(TINYXML_INCLUDE_DIR ${CMAKE_SOURCE_DIR}/thirdparty/tinyxml)
+        set(TINYXML_LIBRARIES tinyxml)
+    else()
+        find_package(TinyXML REQUIRED)
+    endif()
+endmacro()
+
+macro(FindOrBuildSDL2)
+    if(ANDROID)
+        set(ENV{SDL2DIR} "$ENV{ANDROID_SDL2_ROOT};$ENV{ANDROID_SDL2_ROOT}/libs/${ANDROID_NDK_ABI_NAME}/")
+    elseif(WIN32)
+        set(ENV{SDL2DIR} $ENV{WIN_SDL2_ROOT})
+    endif()
+
+    find_package(SDL2)
+endmacro()
+
+macro(FindOrBuildUNZIP)
+    if(BUILD_UNZIP)
+        add_subdirectory(
+            ${CMAKE_SOURCE_DIR}/thirdparty/unzip 
+            ${CMAKE_BINARY_DIR}/thirdparty/unzip)
+        set(UNZIP_INCLUDE_DIR ${CMAKE_SOURCE_DIR}/thirdparty/unzip)
+        set(UNZIP_LIBRARY unzip)
+    else()
+        message(WARNING "UNZIP must get build")
+    endif()
+endmacro()
+
+macro(FindOrBuildBoost)
+    if(PSP OR UNIX)
+        #the psp build does not need more than a few headers
+        #todo: remove from the repository
+        set(BOOST_INCLUDE_DIRS ${CMAKE_SOURCE_DIR}/thirdparty)    
+    elseif(WIN32)
+        #set BOOST_ROOT to the root of boost
+        set(Boost_USE_STATIC_LIBS ON)
+        set(Boost_USE_MULTITHREADED ON)
+        set(BOOST_ROOT $ENV{BOOST_ROOT})
+		
+        set(BOOST_LIBRARYDIR ${BOOST_ROOT}/libs)
+        set(BOOST_INCLUDEDIR ${BOOST_ROOT})
+        
+		find_package(Boost COMPONENTS system thread date_time REQUIRED)
+		if(NOT Boost_FOUND)
+            message("Set the BOOST_ROOT environment variable to point to your boost installation.")
+            message("We need system thread and date_time compiled static libs")
+            message("These libs are compiler specific.")
+		endif()
+#    elseif(UNIX AND NOT ANDROID)
+#        find_package(Boost COMPONENTS system thread date_time REQUIRED)
+    elseif(ANDROID)
+        #this is a hack. we compile a few boost libds directly into 
+        #the application. we should require static libs for android
+        #to be available. maybe we could add the build option to
+        #download and build a compatible boost version
+        find_path(BOOST_INCLUDE_DIRS NAMES bind.hpp HINTS $ENV{ANDROID_BOOST_ROOT} PATH_SUFFIXES boost)
+        
+        if(BOOST_INCLUDE_DIRS)
+            get_filename_component(BOOST_INCLUDE_DIRS ${BOOST_INCLUDE_DIRS} PATH)
+            set(ANDROID_BOOST_PTHREAD_SRC_DIR ${BOOST_INCLUDE_DIRS}/libs/thread/src/pthread)
+            set(ANDROID_BOOST_SYSTEM_SRC_DIR ${BOOST_INCLUDE_DIRS}/libs/system/src/)
+        else()
+            message(SEND_ERROR "We require a few boost sources to get compiled into wagic. Please point the ANDROID_BOOST_ROOT environment variable to a boost-source copy root.")
+        endif()
+    endif()
+endmacro()
+
+macro(FindOrBuildZLIB)
+    if(BUILD_ZLIB)
+        message(WARNING "ZLIB sources are currently not included within the wagic tree")
+    else()
+        if(WIN32)
+            set(ZLIB_ROOT ${CMAKE_SOURCE_DIR}/thirdparty/binary/win)
+            find_package(ZLIB)
+        else()
+            find_package(ZLIB)
+        endif()
+	endif()
+endmacro()
+
+macro(FindOrBuildGIF)
+    if(BUILD_GIF)
+        message(WARNING "ZLIB sources are currently not included within the wagic tree")
+    else()
+        if(WIN32)
+            set(ENV{GIF_DIR} ${CMAKE_SOURCE_DIR}/thirdparty/binary/win)
+            find_package(GIF)
+        else()
+            find_package(GIF)
+        endif()
+    endif()
+endmacro()
+
+macro(FindOrBuildJPEG)
+    if(BUILD_JPEG)
+        add_subdirectory(${CMAKE_SOURCE_DIR}/thirdparty/libjpeg ${CMAKE_BINARY_DIR}/thirdparty/libjpeg)
+        set(JPEG_INCLUDE_DIR ${CMAKE_SOURCE_DIR}/thirdparty/libjpeg)
+        set(JPEG_LIBRARY jpeg)
+    else()
+        if(WIN32)
+            #findJPEG does currently not provide prefix vars to guide it
+            find_path(JPEG_INCLUDE_DIR jpeglib.h HINTS ${CMAKE_SOURCE_DIR}/thirdparty/binary/win/include)
+            find_library(JPEG_LIBRARY NAMES libjpeg-static-mt HINTS ${CMAKE_SOURCE_DIR}/thirdparty/binary/win/lib)
+            
+            if(JPEG_INCLUDE_DIR AND JPEG_LIBRARY)
+                set(JPEG_FOUND ON)
+                mark_as_advanced(JPEG_INCLUDE_DIR JPEG_LIBRARY)
+            else()
+                message(FATAL_ERROR "Could not find JPEG on windows")
+            endif()
+        else()
+            find_package(JPEG)
+        endif()
+    endif()
+endmacro()
+
+macro(FindOrBuildPNG)
+    if(BUILD_PNG)
+        add_subdirectory(${CMAKE_SOURCE_DIR}/thirdparty/libpng ${CMAKE_BINARY_DIR}/thirdparty/libpng)
+        find_path(PNG_INCLUDE_DIRS NAMES png.h HINTS ${CMAKE_SOURCE_DIR}/thirdparty/libpng)
+        set(PNG_LIBRARIES png)
+    else()
+        if(WIN32)
+            #findPNG does currently not provide prefix vars. so we find
+            find_path(PNG_INCLUDE_DIRS png.h HINTS ${CMAKE_SOURCE_DIR}/thirdparty/binary/win/include)
+            find_library(PNG_LIBRARIES libpng HINTS ${CMAKE_SOURCE_DIR}/thirdparty/binary/win/lib)
+                    
+            if (PNG_LIBRARIES AND PNG_INCLUDE_DIRS)
+                set(PNG_FOUND ON)
+                mark_as_advanced(PNG_INCLUDE_DIRS PNG_LIBRARIES)
+            else()
+                message(FATAL_ERROR "Could not find PNG on windows")
+            endif()
+        else()
+            find_package(PNG)
+        endif()
+    endif()
+endmacro()
+
+macro(FindOrBuildFreetype)
+    if(PSP)
+        set(ENV{FREETYPE_DIR} ${CMAKE_SOURCE_DIR}/thirdparty/binary/psp)
+	elseif(WIN32)
+	    set(ENV{FREETYPE_DIR} ${CMAKE_SOURCE_DIR}/thirdparty/binary/win)
+    endif()
+    
+	find_package(Freetype)
+endmacro()
+
+macro(FindOrBuildHgeTools)
+	if(PSP)
+		find_library(HGETOOLS_LIBRARY NAMES hgetools HINTS "${CMAKE_SOURCE_DIR}/thirdparty/binary/psp/lib")
+		set(HGETOOLS_INCLUDE_DIRS "${CMAKE_SOURCE_DIR}/thirdparty/binary/psp/include")
+	endif()
+endmacro()
+
+macro(FindOrBuildMikMod)
+	if(PSP)
+		find_library(MIKMOD_LIBRARY NAMES mikmod HINTS "${CMAKE_SOURCE_DIR}/thirdparty/binary/psp/lib")
+        set(MIKMOD_INCLUDE_DIRS "${CMAKE_SOURCE_DIR}/thirdparty/binary/psp/include")
+    endif()
+endmacro()
+
+macro(FindOrBuildQt)
+    if(backend_qt_console)
+        add_definitions(-DCONSOLE_CONFIG -DTESTSUITE)
+        find_package(Qt5Core REQUIRED)
+        find_package(Qt5 COMPONENTS Core Network Multimedia REQUIRED)
+    elseif(backend_qt_widget)
+        add_definitions(-DQT_WIDGET)
+        find_package(OpenGL REQUIRED)
+        find_package(X11 REQUIRED)
+        find_package(Qt5 COMPONENTS Core Gui OpenGL Network Multimedia REQUIRED)
+    endif()
+#    include(${QT_USE_FILE})
+endmacro()
+
+macro(FindOrBuildOpenGL)
+    if(backend_sdl OR backend_qt_console OR backend_qt_widget)
+        if(ANDROID)
+            #find openglesv on android
+            set(OPENGL_LIBRARIES "-ldl -lGLESv1_CM -lGLESv2 -llog -landroid")
+        else()
+            find_package(OpenGL)
+        endif()
+    endif()
+endmacro()
+
+macro(FindOrBuildOpenSL)
+    find_package(OpenSL)
+endmacro()
+
+macro(FindOrBuildPSPSDK)
+    find_package(PSPSDK COMPONENTS psppower pspmpeg pspaudiocodec pspaudiolib pspaudio pspmp3 pspgum pspgu psprtc pspfpu REQUIRED)
+endmacro()
+

CMakeModules/FindPSPSDK.cmake

@@ -0,0 +1,62 @@
+# - Try to find PSPSDK
+# Once done this will define
+#  PSPSDK_FOUND - System has PSPSDK
+#  PSPSDK_INCLUDE_DIR - The PSPSDK include directories
+#  PSPSDK_LIB - The libraries requested with the components field
+#  PSPSDK_REQUIRED_LIB - The libriries the PSPSDK needs always
+#  PSPSDK_CFLAGS  - The CFLAGS to use
+#  PSPSDK_PATH - The output of psp-config --pspsdk-path
+#  PSPSDK_PREFIX - The output of psp-config --psp-prefix
+#  PSPSDK_CXX_COMPILER - The PSPSDK CXX Compilers path
+#  PSPSDK_CXX_LINKER - The PSPSDK CXX Linker command
+#  PSPSDK_FIXUP_IMPORTS_COMMAND - psp-fixup-imports command
+#  PSPSDK_PRXGEN_COMMAND - psp-prxgen command
+#  PSPSDK_PACK_PBP_COMMAND - pack-pbp command
+#  PSPSDK_MKSFO_COMMAND - mksfo command
+
+#find the psp-config progams absolute path
+#psp-config needs to be reachable via the system shell (PATH)
+find_program(PSP_CONFIG_PROGRAM psp-config)
+
+#TODO: check if something is REQUIRED and throw errors instead of messages        
+if(PSP_CONFIG_PROGRAM)
+    find_program(PSPSDK_CXX_COMPILER psp-g++)
+    find_program(PSPSDK_CXX_LINKER psp-gcc)
+    find_program(PSPSDK_FIXUP_IMPORTS_COMMAND psp-fixup-imports)
+    find_program(PSPSDK_PRXGEN_COMMAND psp-prxgen)
+    find_program(PSPSDK_PACK_PBP_COMMAND pack-pbp)
+    find_program(PSPSDK_MKSFO_COMMAND mksfo)
+
+    #ask psp-config for the 
+    execute_process(COMMAND psp-config --pspsdk-path OUTPUT_VARIABLE PSPSDK_PATH OUTPUT_STRIP_TRAILING_WHITESPACE)
+    execute_process(COMMAND psp-config --psp-prefix  OUTPUT_VARIABLE PSPSDK_PREFIX OUTPUT_STRIP_TRAILING_WHITESPACE)
+	
+    set(PSPSDK_INCLUDE_DIR "${PSPSDK_PATH}/include")
+    
+    foreach(_COMPONENT ${PSPSDK_FIND_COMPONENTS})
+        find_library(PSPSDK_${_COMPONENT} NAMES ${_COMPONENT})
+        if(NOT PSPSDK_${_COMPONENT})
+            message(SEND_ERROR "PSPSDK: ${_COMPONENT} not found")
+        else()
+            set(PSPSDK_LIB ${PSPSDK_LIB} ${PSPSDK_${_COMPONENT}})
+        endif()
+    endforeach()
+    
+    #find libs which pspsdk does require to link even if the programs does not need one of them directly
+    foreach(_COMPONENT pspdebug pspdisplay pspge pspctrl pspsdk c pspnet pspnet_inet pspnet_apctl pspnet_resolver psputility pspuser)
+        find_library(PSPSDK_${_COMPONENT} NAMES ${_COMPONENT})
+        if(NOT PSPSDK_${_COMPONENT})
+            message(SEND_ERROR "PSPSDK: ${_COMPONENT} not found")
+        else()
+            set(PSPSDK_REQUIRED_LIB ${PSPSDK_REQUIRED_LIB} ${PSPSDK_${_COMPONENT}})
+        endif()
+    endforeach()
+endif()
+
+include(FindPackageHandleStandardArgs)
+# handle the QUIETLY and REQUIRED arguments and set LIBXML2_FOUND to TRUE
+# if all listed variables are TRUE
+find_package_handle_standard_args(PSPSDK  DEFAULT_MSG
+                                  PSPSDK_CXX_LINKER PSPSDK_CXX_COMPILER PSPSDK_PATH PSPSDK_PREFIX PSPSDK_LIB PSPSDK_REQUIRED_LIB PSPSDK_INCLUDE_DIR)
+
+mark_as_advanced(PSPSDK_CXX_LINKER PSPSDK_CXX_COMPILER PSPSDK_PATH PSPSDK_PREFIX PSPSDK_LIB PSPSDK_REQUIRED_LIB PSPSDK_INCLUDE_DIR)

CMakeModules/FindSDL2.cmake

@@ -0,0 +1,181 @@
+ 
+# Locate SDL2 library
+# This module defines
+# SDL2_LIBRARY, the name of the library to link against
+# SDL2_FOUND, if false, do not try to link to SDL2
+# SDL2_INCLUDE_DIR, where to find SDL.h
+#
+# This module responds to the the flag:
+# SDL2_BUILDING_LIBRARY
+# If this is defined, then no SDL2_main will be linked in because
+# only applications need main().
+# Otherwise, it is assumed you are building an application and this
+# module will attempt to locate and set the the proper link flags
+# as part of the returned SDL2_LIBRARY variable.
+#
+# Don't forget to include SDL2main.h and SDL2main.m your project for the
+# OS X framework based version. (Other versions link to -lSDL2main which
+# this module will try to find on your behalf.) Also for OS X, this
+# module will automatically add the -framework Cocoa on your behalf.
+#
+#
+# Additional Note: If you see an empty SDL2_LIBRARY_TEMP in your configuration
+# and no SDL2_LIBRARY, it means CMake did not find your SDL2 library
+# (SDL2.dll, libsdl2.so, SDL2.framework, etc).
+# Set SDL2_LIBRARY_TEMP to point to your SDL2 library, and configure again.
+# Similarly, if you see an empty SDL2MAIN_LIBRARY, you should set this value
+# as appropriate. These values are used to generate the final SDL2_LIBRARY
+# variable, but when these values are unset, SDL2_LIBRARY does not get created.
+#
+#
+# $SDL2DIR is an environment variable that would
+# correspond to the ./configure --prefix=$SDL2DIR
+# used in building SDL2.
+# l.e.galup  9-20-02
+#
+# Modified by Eric Wing.
+# Added code to assist with automated building by using environmental variables
+# and providing a more controlled/consistent search behavior.
+# Added new modifications to recognize OS X frameworks and
+# additional Unix paths (FreeBSD, etc).
+# Also corrected the header search path to follow "proper" SDL2 guidelines.
+# Added a search for SDL2main which is needed by some platforms.
+# Added a search for threads which is needed by some platforms.
+# Added needed compile switches for MinGW.
+#
+# On OSX, this will prefer the Framework version (if found) over others.
+# People will have to manually change the cache values of
+# SDL2_LIBRARY to override this selection or set the CMake environment
+# CMAKE_INCLUDE_PATH to modify the search paths.
+#
+# Note that the header path has changed from SDL2/SDL.h to just SDL.h
+# This needed to change because "proper" SDL2 convention
+# is #include "SDL.h", not <SDL2/SDL.h>. This is done for portability
+# reasons because not all systems place things in SDL2/ (see FreeBSD).
+#
+# Ported by Johnny Patterson. This is a literal port for SDL2 of the FindSDL.cmake
+# module with the minor edit of changing "SDL" to "SDL2" where necessary. This
+# was not created for redistribution, and exists temporarily pending official
+# SDL2 CMake modules.
+
+#=============================================================================
+# Copyright 2003-2009 Kitware, Inc.
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+FIND_PATH(SDL2_INCLUDE_DIR SDL.h
+  HINTS
+  $ENV{SDL2DIR}
+  PATH_SUFFIXES include/SDL2 include
+  PATHS
+  ~/Library/Frameworks
+  /Library/Frameworks
+  /usr/local/include/SDL2
+  /usr/include/SDL2
+  /sw # Fink
+  /opt/local # DarwinPorts
+  /opt/csw # Blastwave
+  /opt
+)
+
+FIND_LIBRARY(SDL2_LIBRARY_TEMP
+  NAMES SDL2
+  HINTS
+  $ENV{SDL2DIR}
+  PATH_SUFFIXES lib64 lib
+  PATHS
+  /sw
+  /opt/local
+  /opt/csw
+  /opt
+)
+
+#MESSAGE("SDL2_LIBRARY_TEMP is ${SDL2_LIBRARY_TEMP}")
+
+IF(NOT SDL2_BUILDING_LIBRARY)
+  IF(NOT ${SDL2_INCLUDE_DIR} MATCHES ".framework")
+    # Non-OS X framework versions expect you to also dynamically link to
+    # SDL2main. This is mainly for Windows and OS X. Other (Unix) platforms
+    # seem to provide SDL2main for compatibility even though they don't
+    # necessarily need it.
+    FIND_LIBRARY(SDL2MAIN_LIBRARY
+      NAMES SDL2main
+      HINTS
+      $ENV{SDL2DIR}
+      PATH_SUFFIXES lib64 lib
+      PATHS
+      /sw
+      /opt/local
+      /opt/csw
+      /opt
+    )
+  ENDIF(NOT ${SDL2_INCLUDE_DIR} MATCHES ".framework")
+ENDIF(NOT SDL2_BUILDING_LIBRARY)
+
+# SDL2 may require threads on your system.
+# The Apple build may not need an explicit flag because one of the
+# frameworks may already provide it.
+# But for non-OSX systems, I will use the CMake Threads package.
+IF(NOT APPLE)
+  FIND_PACKAGE(Threads)
+ENDIF(NOT APPLE)
+
+# MinGW needs an additional library, mwindows
+# It's total link flags should look like -lmingw32 -lSDL2main -lSDL2 -lmwindows
+# (Actually on second look, I think it only needs one of the m* libraries.)
+IF(MINGW)
+  SET(MINGW32_LIBRARY mingw32 CACHE STRING "mwindows for MinGW")
+ENDIF(MINGW)
+
+SET(SDL2_FOUND "NO")
+IF(SDL2_LIBRARY_TEMP)
+  # For SDL2main
+  IF(NOT SDL2_BUILDING_LIBRARY)
+    IF(SDL2MAIN_LIBRARY)
+      SET(SDL2_LIBRARY_TEMP ${SDL2MAIN_LIBRARY} ${SDL2_LIBRARY_TEMP})
+    ENDIF(SDL2MAIN_LIBRARY)
+  ENDIF(NOT SDL2_BUILDING_LIBRARY)
+
+  # For OS X, SDL2 uses Cocoa as a backend so it must link to Cocoa.
+  # CMake doesn't display the -framework Cocoa string in the UI even
+  # though it actually is there if I modify a pre-used variable.
+  # I think it has something to do with the CACHE STRING.
+  # So I use a temporary variable until the end so I can set the
+  # "real" variable in one-shot.
+  IF(APPLE)
+    SET(SDL2_LIBRARY_TEMP ${SDL2_LIBRARY_TEMP} "-framework Cocoa")
+  ENDIF(APPLE)
+
+  # For threads, as mentioned Apple doesn't need this.
+  # In fact, there seems to be a problem if I used the Threads package
+  # and try using this line, so I'm just skipping it entirely for OS X.
+  IF(NOT APPLE)
+    SET(SDL2_LIBRARY_TEMP ${SDL2_LIBRARY_TEMP} ${CMAKE_THREAD_LIBS_INIT})
+  ENDIF(NOT APPLE)
+
+  # For MinGW library
+  IF(MINGW)
+    SET(SDL2_LIBRARY_TEMP ${MINGW32_LIBRARY} ${SDL2_LIBRARY_TEMP})
+  ENDIF(MINGW)
+
+  # Set the final string here so the GUI reflects the final state.
+  SET(SDL2_LIBRARY ${SDL2_LIBRARY_TEMP} CACHE STRING "Where the SDL2 Library can be found")
+  # Set the temp variable to INTERNAL so it is not seen in the CMake GUI
+  SET(SDL2_LIBRARY_TEMP "${SDL2_LIBRARY_TEMP}" CACHE INTERNAL "")
+
+  SET(SDL2_FOUND "YES")
+ENDIF(SDL2_LIBRARY_TEMP)
+
+INCLUDE(FindPackageHandleStandardArgs)
+
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(SDL2
+                                  REQUIRED_VARS SDL2_LIBRARY SDL2_INCLUDE_DIR)
+mark_as_advanced(SDL2MAIN_LIBRARY SDL2_LIBRARY SDL2_INCLUDE_DIR)

CMakeModules/FindTinyXML.cmake

@@ -0,0 +1,26 @@
+# - Find TinyXML
+# Find the native TinyXML includes and library
+#
+#   TINYXML_FOUND       - True if TinyXML found.
+#   TINYXML_INCLUDE_DIR - where to find tinyxml.h, etc.
+#   TINYXML_LIBRARIES   - List of libraries when using TinyXML.
+#
+
+IF( TINYXML_INCLUDE_DIR )
+    # Already in cache, be silent
+    SET( TinyXML_FIND_QUIETLY TRUE )
+ENDIF( TINYXML_INCLUDE_DIR )
+
+FIND_PATH( TINYXML_INCLUDE_DIR "tinyxml.h"
+           PATH_SUFFIXES "tinyxml" )
+
+FIND_LIBRARY( TINYXML_LIBRARIES
+              NAMES "tinyxml"
+              PATH_SUFFIXES "tinyxml" )
+
+# handle the QUIETLY and REQUIRED arguments and set TINYXML_FOUND to TRUE if
+# all listed variables are TRUE
+INCLUDE( "FindPackageHandleStandardArgs" )
+FIND_PACKAGE_HANDLE_STANDARD_ARGS( "TinyXML" DEFAULT_MSG TINYXML_INCLUDE_DIR TINYXML_LIBRARIES )
+
+MARK_AS_ADVANCED( TINYXML_INCLUDE_DIR TINYXML_LIBRARIES )

CMakeModules/psp.toolchain.cmake

@@ -0,0 +1,62 @@
+include(CMakeForceCompiler)
+
+# this one is important
+SET(CMAKE_SYSTEM_NAME "Generic")
+#this one not so much
+SET(CMAKE_SYSTEM_VERSION 1)
+
+find_program(PSP_CONFIG_PROGRAM psp-config)
+
+execute_process(COMMAND psp-config --pspsdk-path OUTPUT_VARIABLE PSPSDK_PATH OUTPUT_STRIP_TRAILING_WHITESPACE)
+execute_process(COMMAND psp-config --psp-prefix  OUTPUT_VARIABLE PSPSDK_PREFIX OUTPUT_STRIP_TRAILING_WHITESPACE)
+	
+# specify compiler and linker:
+find_program(PSP_GPP psp-g++)
+find_program(PSP_GCC psp-gcc)
+
+CMAKE_FORCE_C_COMPILER(${PSP_GCC} GNU)
+CMAKE_FORCE_CXX_COMPILER(${PSP_GPP} GNU)
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -G0")
+
+set(CMAKE_SHARED_LIBRARY_LINK_CXX_FLAGS "")
+set(CMAKE_CXX_LINK_EXECUTABLE "${PSP_GCC} <CMAKE_CXX_LINK_FLAGS> <LINK_FLAGS> <FLAGS> <OBJECTS>  -o <TARGET> <LINK_LIBRARIES>")
+
+#how libraries look
+SET(CMAKE_FIND_LIBRARY_PREFIXES "lib")
+SET(CMAKE_FIND_LIBRARY_SUFFIXES ".so" ".a")
+
+# where is the target environment 
+SET(CMAKE_SYSTEM_INCLUDE_PATH 
+	${CMAKE_SOURCE_DIR}/thirdparty/binary/psp/include 
+	${PSPSDK_PATH}/include 
+	${PSPSDK_PREFIX}/include 
+	${CMAKE_INSTALL_PREFIX}/include
+	${CMAKE_SYSTEM_INCLUDE_PATH})
+	
+SET(CMAKE_SYSTEM_LIBRARY_PATH 
+	${CMAKE_SOURCE_DIR}/thirdparty/binary/psp/lib 
+	${PSPSDK_PATH}/lib 
+	${PSPSDK_PREFIX}/lib
+	${CMAKE_INSTALL_PREFIX}/lib
+	${CMAKE_SYSTEM_LIBRARY_PATH})
+
+SET(CMAKE_FIND_ROOT_PATH  
+	${CMAKE_SOURCE_DIR}/thirdparty/binary/psp
+	${CMAKE_SOURCE_DIR}/thirdparty/binary/psp/lib
+	${CMAKE_SOURCE_DIR}/thirdparty/binary/psp/include
+	${PSPSDK_PATH}
+	${PSPSDK_PATH}/lib
+	${PSPSDK_PATH}/include
+	${PSPSDK_PREFIX}
+	${PSPSDK_PREFIX}/lib
+	${PSPSDK_PREFIX}/include
+	)
+
+# search for programs in the build host directories
+# for libraries and headers in the target directories and then in the host
+SET(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+SET(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY FIRST)
+SET(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE FIRST)
+
+set(PSP 1)

CMakeModules/utils.cmake

@@ -0,0 +1,57 @@
+macro(WAGIC_OPTION variable description value)
+  set(__value ${value})
+  set(__condition "")
+  set(__varname "__value")
+  foreach(arg ${ARGN})
+    if(arg STREQUAL "IF" OR arg STREQUAL "if")
+      set(__varname "__condition")
+    else()
+      list(APPEND ${__varname} ${arg})
+    endif()
+  endforeach()
+  unset(__varname)
+  if("${__condition}" STREQUAL "")
+    set(__condition 2 GREATER 1)
+  endif()
+
+  if(${__condition})
+    if("${__value}" MATCHES ";")
+      if(${__value})
+        option(${variable} "${description}" ON)
+      else()
+        option(${variable} "${description}" OFF)
+      endif()
+    elseif(DEFINED ${__value})
+      if(${__value})
+        option(${variable} "${description}" ON)
+      else()
+        option(${variable} "${description}" OFF)
+      endif()
+    else()
+      option(${variable} "${description}" ${__value})
+    endif()
+  else()
+    unset(${variable} CACHE)
+  endif()
+  unset(__condition)
+  unset(__value)
+endmacro() 
+
+# add prefix to each item in the list
+macro(list_add_prefix LST PREFIX)
+  set(__tmp "")
+  foreach(item ${${LST}})
+    list(APPEND __tmp "${PREFIX}${item}")
+  endforeach()
+  set(${LST} ${__tmp})
+  unset(__tmp)
+endmacro()
+
+
+macro(find_host_program)
+    set(_find_program ${CMAKE_FIND_ROOT_PATH_MODE_PROGRAM})
+    set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+    find_program(${ARGN})
+    set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ${_find_program})
+    unset(_find_program)
+endmacro()

JGE/CMakeLists.txt

@@ -0,0 +1,143 @@
+#the sources, jge will need always
+set(JGE_generic_src
+        src/Encoding.cpp
+        src/JAnimator.cpp
+        src/JApp.cpp
+        src/JDistortionMesh.cpp
+        src/JFileSystem.cpp
+        src/JGameObject.cpp
+        src/JGE.cpp
+        src/JGui.cpp
+        src/JLogger.cpp
+        src/JLBFont.cpp
+        src/JOBJModel.cpp
+        src/JParticle.cpp
+        src/JParticleEffect.cpp
+        src/JParticleEmitter.cpp
+        src/JParticleSystem.cpp
+        src/JResourceManager.cpp
+        src/JSpline.cpp
+        src/JNetwork.cpp
+        src/JSprite.cpp
+        src/Vector2D.cpp)
+
+set(JGE_hge_src
+        src/hge/hgecolor.cpp
+        src/hge/hgedistort.cpp
+        src/hge/hgefont.cpp
+        src/hge/hgeparticle.cpp
+        src/hge/hgerect.cpp
+        src/hge/hgevector.cpp)
+
+#the sources we need to get graphical output desktops
+#used by qt-widget build option
+set(JGE_graphics_src
+        src/Downloader.cpp
+        include/Downloader.h
+        src/JMD2Model.cpp
+        src/pc/JGfx.cpp)
+
+#the sources we need to fake graphical output on desktops
+#these are used for the console-only testsuit
+set(JGE_console_src
+        src/OutputCapturer.cpp
+        src/JGfx-fake.cpp)
+
+#the sources we need on linux
+set(JGE_linux_src
+        src/pc/JSocket.cpp
+        src/pc/JSfx.cpp)
+        
+set(JGE_android_src
+        src/JSocket.cpp 
+        src/android/JSfx.cpp)
+
+#the sources we need if we compile for psp
+#note: main.cpp contains the main-function.
+#the other main functions reside in projects/mtg to reduce cross-library dependencies.
+#there may be a way to get all main-functions into the same project
+set(JGE_psp_src
+        src/JSocket.cpp 
+        src/JGfx.cpp
+        src/JSfx.cpp
+        src/JAudio.cpp
+        src/JMP3.cpp
+        src/decoder_prx.cpp
+        src/main.cpp
+        src/vram.cpp)
+
+set(JGE_INCLUDE_DIRS include include/hge)
+
+#turn moc on
+if(backend_qt_console OR backend_qt_widget)
+    set(CMAKE_INCLUDE_CURRENT_DIR ON)
+    set(CMAKE_AUTOMOC TRUE)
+endif()
+
+
+if(backend_qt_console)
+    if(UNIX AND NOT ANDROID)
+        set(JGE_INTERNAL_INCLUDE_DIRS ${TINYXML_INCLUDE_DIR} ${ZIPFS_INCLUDE_DIR} 
+            ${UNZIP_INCLUDE_DIR} ${QT_MKSPECS_DIR}/default ${Qt5Core_INCLUDE_DIRS} ${Qt5Multimedia_INCLUDE_DIRS})
+        set(JGE_SOURCES ${JGE_generic_src} ${JGE_console_src} ${JGE_linux_src} ${JGE_hge_src})
+        set(JGE_LINK_LIBRARIES ${Qt5Core_LIBRARIES} ${Qt5Multimedia_LIBRARIES} ${ZIPFS_LIBRARY} ${UNZIP_LIRARY} ${GIF_LIBRARIES}
+            ${JPEG_LIBRARIES} ${PNG_LIBRARIES})
+    else()
+        message(FATAL_ERROR "qt builds of jge platforms other than linux are not supported")
+    endif()
+endif()
+
+if(backend_qt_widget)
+    if(UNIX AND NOT ANDROID)
+        set(JGE_INTERNAL_INCLUDE_DIRS ${TINYXML_INCLUDE_DIR} ${ZIPFS_INCLUDE_DIR} 
+            ${UNZIP_INCLUDE_DIR} ${QT_MKSPECS_DIR}/default ${Qt5Core_INCLUDE_DIRS} ${Qt5Multimedia_INCLUDE_DIRS} ${Qt5OpenGL_INCLUDE_DIRS} )
+        set(JGE_SOURCES ${JGE_generic_src} ${JGE_graphics_src} ${JGE_linux_src} ${JGE_hge_src})
+        set(JGE_LINK_LIBRARIES ${Qt5Core_LIBRARIES} ${Qt5Multimedia_LIBRARIES} ${Qt5OpenGL_LIBRARIES} ${ZIPFS_LIBRARY} ${UNZIP_LIRARY}
+            ${GIF_LIBRARIES} ${JPEG_LIBRARIES} ${PNG_LIBRARIES})
+    else()
+        message(FATAL_ERROR "qt builds of jge platforms other than linux are not supported")
+    endif()
+endif()
+
+if(backend_sdl)
+    if(UNIX AND NOT ANDROID)
+        set(JGE_INTERNAL_INCLUDE_DIRS ${TINYXML_INCLUDE_DIR} ${ZIPFS_INCLUDE_DIR}   
+            ${SDL2_INCLUDE_DIR} ${UNZIP_INCLUDE_DIR} ${PNG_INCLUDE_DIRS} ${BOOST_INCLUDE_DIRS})
+        set(JGE_SOURCES ${JGE_generic_src} ${JGE_graphics_src} ${JGE_linux_src} ${JGE_hge_src})
+        set(JGE_LINK_LIBRARIES ${ZIPFS_LIBRARY} ${UNZIP_LIRARY} ${GIF_LIBRARIES} ${JPEG_LIBRARY} 
+            ${PNG_LIBRARIES})
+    elseif(ANDROID)
+        set(JGE_INTERNAL_INCLUDE_DIRS ${BOOST_INCLUDE_DIRS} ${TINYXML_INCLUDE_DIR} ${ZIPFS_INCLUDE_DIR}     
+            ${SDL2_INCLUDE_DIR} ${UNZIP_INCLUDE_DIR} ${PNG_INCLUDE_DIRS} ${JPEG_INCLUDE_DIR} 
+            ${OPENSL_INCLUDE_DIR})
+        set(JGE_SOURCES ${JGE_generic_src} ${JGE_android_src} ${JGE_graphics_src} ${JGE_hge_src})
+        set(JGE_LINK_LIBRARIES ${ZIPFS_LIBRARY} ${UNZIP_LIRARY} ${JPEG_LIBRARY} ${PNG_LIBRARIES} 
+            ${OPENSL_LIBRARIES}) 
+    elseif(WIN32)
+        set(JGE_INTERNAL_INCLUDE_DIRS ${TINYXML_INCLUDE_DIR} ${ZIPFS_INCLUDE_DIR} ${SDL2_INCLUDE_DIR} 
+            ${UNZIP_INCLUDE_DIR} ${GIF_INCLUDE_DIR} ${Boost_INCLUDE_DIR})
+        set(JGE_SOURCES ${JGE_generic_src} ${JGE_graphics_src} ${JGE_linux_src} ${JGE_hge_src})
+        set(JGE_LINK_LIBRARIES ${ZIPFS_LIBRARY} ${UNZIP_LIRARY} ${GIF_LIBRARIES} ${JPEG_LIBRARY} 
+            ${PNG_LIBRARIES})
+        set(JGE_LINK_DIRECTORIES ${Boost_LIBRARY_DIR} ${SDL2_LIBRARY_DIR})
+    endif()
+endif()
+
+if(backend_psp)
+    if(PSP)        
+        #${PSPSDK_PATH}/include should be in system pathes
+        set(JGE_INTERNAL_INCLUDE_DIRS ${CMAKE_SOURCE_DIR}/thirdparty/psp/include ${TINYXML_INCLUDE_DIR} 
+            ${ZIPFS_INCLUDE_DIR} ${UNZIP_INCLUDE_DIR} ${BOOST_INCLUDE_DIRS} ${GIF_INCLUDE_DIR})
+        set(JGE_SOURCES ${JGE_generic_src} ${JGE_psp_src} ${JGE_hge_src})
+        set(JGE_LINK_LIBRARIES ${TINYXML_LIBRARIES} ${ZIPFS_LIBRARY} ${UNZIP_LIRARY})
+    else()
+        message(FATAL_ERROR "use the cross-compile toolchain to build as the psp target")
+    endif()
+endif()
+
+add_library(jge STATIC ${JGE_SOURCES})
+include_directories(${JGE_INTERNAL_INCLUDE_DIRS} ${JGE_INCLUDE_DIRS})
+target_link_libraries(jge ${JGE_LINK_LIBRARIES})
+link_directories(${JGE_LINK_DIRECTORIES})
+
+set(${JGE_LIBRARIES} jge)

JGE/include/PrecompiledHeader.h

@@ -0,0 +1,29 @@
+#ifndef PRECOMPILEDHEADER_H
+#define PRECOMPILEDHEADER_H
+
+#include <algorithm>
+#include <fstream>
+#include <iostream>
+#include <list>
+#include <map>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#include "DebugRoutines.h"
+
+#include <assert.h>
+
+#include "JGE.h"
+#include "JFileSystem.h"
+#include "JLogger.h"
+
+//#ifndef WP8
+//#include <boost/shared_ptr.hpp>
+//#endif
+
+#if defined (WP8) || defined (IOS) || defined (ANDROID) || defined (QT_CONFIG) || defined (SDL_CONFIG)
+#define TOUCH_ENABLED
+#endif
+
+#endif //PRECOMPILEDHEADER_H

JGE/src/JAnimator.cpp

@@ -15,7 +15,7 @@
 #include "../include/JSprite.h"
 #include "../include/JAnimator.h"
 
-#include "tinyxml/tinyxml.h"
+#include "tinyxml.h"
 
 
 //////////////////////////////////////////////////////////////////////////

JGE/src/JParticleEffect.cpp

@@ -19,7 +19,7 @@
 #include "../include/JFileSystem.h"
 #include "../include/JResourceManager.h"
 
-#include "tinyxml/tinyxml.h"
+#include "tinyxml.h"
 
 //-------------------------------------------------------------------------------------
 

JGE/src/JResourceManager.cpp

@@ -14,7 +14,7 @@
 #include "../include/JResourceManager.h"
 #include "../include/JFileSystem.h"
 #include "../include/JLBFont.h"
-#include "tinyxml/tinyxml.h"
+#include "tinyxml.h"
 
 #if defined (_DEBUG) && defined (WIN32) && (!defined LINUX)
 #include "crtdbg.h"

JGE/src/JSpline.cpp

@@ -13,7 +13,7 @@
 #include "../include/JFileSystem.h"
 #include "../include/JSpline.h"
 
-#include "tinyxml/tinyxml.h"
+#include "tinyxml.h"
 
 #define SMALL_NUMBER		0.0001f
 

platforms/android/configure.cmake

@@ -0,0 +1,2 @@
+add_definitions(-DANDROID -DLINUX)
+add_definitions(-D_STLP_USE_SIMPLE_NODE_ALLOC -D__arm__ -D_REENTRANT -D_GLIBCXX__PTHREADS)  

platforms/android/package/AndroidManifest.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8" standalone="no"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" android:versionCode="0192" android:versionName="@string/app_version" package="net.wagic.app">
+    <uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS"/>
+    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
+    <uses-permission android:name="android.permission.INTERNET"/>
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
+    <application android:debuggable="true" android:icon="@drawable/icon" android:label="@string/app_name" android:theme="@android:style/Theme.NoTitleBar.Fullscreen">
+        <activity android:configChanges="keyboard|keyboardHidden|orientation" android:label="@string/app_name" android:name="org.libsdl.app.SDLActivity" android:screenOrientation="sensorLandscape">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN"/>
+                <category android:name="android.intent.category.LAUNCHER"/>
+            </intent-filter>
+        </activity>
+        
+        <activity android:configChanges="keyboard|keyboardHidden|orientation" android:name="com.google.ads.AdActivity" android:screenOrientation="sensorLandscape"/>
+    </application>
+    <uses-sdk android:minSdkVersion="@ANDROID_NATIVE_API_LEVEL@" android:targetSdkVersion="@ANDROID_NATIVE_API_LEVEL@"/>
+</manifest>

platforms/android/package/CMakeLists.txt

@@ -0,0 +1,120 @@
+if(NOT ANDROID_PACKAGE_RELEASE)
+  set(ANDROID_PACKAGE_RELEASE 1)
+endif()
+
+if(NOT ANDROID_PACKAGE_PLATFORM)
+  if(ARMEABI_V7A)
+    if(NEON)
+      set(ANDROID_PACKAGE_PLATFORM armv7a_neon)
+    else()
+      set(ANDROID_PACKAGE_PLATFORM armv7a)
+    endif()
+  elseif(ARMEABI_V6)
+    set(ANDROID_PACKAGE_PLATFORM armv6)
+  elseif(ARMEABI)
+    set(ANDROID_PACKAGE_PLATFORM armv5)
+  elseif(X86)
+    set(ANDROID_PACKAGE_PLATFORM x86)
+  elseif(MIPS)
+    set(ANDROID_PACKAGE_PLATFORM mips)
+  else()
+    message(ERROR "Can not automatically determine the value for ANDROID_PACKAGE_PLATFORM")
+  endif()
+endif()
+
+if(NOT ANDROID_PACKAGE_PLATFORM_NAME)
+  if(ARMEABI_V7A)
+    if(NEON)
+      set(ANDROID_PACKAGE_PLATFORM_NAME "armeabi-v7a with NEON")
+    else()
+      set(ANDROID_PACKAGE_PLATFORM_NAME "armeabi-v7a")
+    endif()
+  elseif(ARMEABI_V6)
+    set(ANDROID_PACKAGE_PLATFORM_NAME "armeabi-v6")
+  elseif(ARMEABI)
+    set(ANDROID_PACKAGE_PLATFORM_NAME "armeabi")
+  elseif(X86)
+    set(ANDROID_PACKAGE_PLATFORM_NAME "x86")
+  elseif(MIPS)
+    set(ANDROID_PACKAGE_PLATFORM_NAME "mips")
+  else()
+    message(ERROR "Can not automatically determine the value for ANDROID_PACKAGE_PLATFORM_NAME")
+  endif()
+endif()
+
+if("${ANDROID_NATIVE_API_LEVEL}" MATCHES "[1-9][0-9]*$")
+  set(ANDROID_SDK_VERSION ${CMAKE_MATCH_0})
+endif()
+
+if(NOT ANDROID_SDK_VERSION GREATER 7)
+  set(ANDROID_SDK_VERSION 8)
+endif()
+
+set(PACKAGE_DIR "${CMAKE_BINARY_DIR}/package")
+
+configure_file("${CMAKE_CURRENT_SOURCE_DIR}/AndroidManifest.xml" 
+    "${PACKAGE_DIR}/AndroidManifest.xml"     @ONLY)
+#configure_file("${CMAKE_CURRENT_SOURCE_DIR}/build.xml" 
+#    "${PACKAGE_DIR}/build.xml"     COPYONLY)
+configure_file("${CMAKE_CURRENT_SOURCE_DIR}/res/values/strings.xml"   
+    "${PACKAGE_DIR}/res/values/strings.xml"       COPYONLY)
+configure_file("${CMAKE_CURRENT_SOURCE_DIR}/res/drawable-hdpi/icon.png"   
+    "${PACKAGE_DIR}/res/drawable-hdpi/icon.png"   COPYONLY)
+configure_file("${CMAKE_CURRENT_SOURCE_DIR}/res/drawable-ldpi/icon.png"   
+    "${PACKAGE_DIR}/res/drawable-ldpi/icon.png"   COPYONLY)
+configure_file("${CMAKE_CURRENT_SOURCE_DIR}/res/drawable-mdpi/icon.png"   
+    "${PACKAGE_DIR}/res/drawable-mdpi/icon.png"   COPYONLY)
+configure_file("${CMAKE_CURRENT_SOURCE_DIR}/res/layout/main.xml"   
+    "${PACKAGE_DIR}/res/layout/main.xml"   COPYONLY)
+configure_file("${CMAKE_CURRENT_SOURCE_DIR}/assets/_keystore/wagic-release.keystore"   
+    "${PACKAGE_DIR}/assets/_keystore/wagic-release.keystore"   COPYONLY)
+    
+string( REGEX MATCH "[0-9]+" ANDROID_NATIVE_API_LEVEL_NUMBER "${ANDROID_NATIVE_API_LEVEL}" )
+
+set(target_name "Wagic_${WAGIC_VERSION}_binary_pack_${ANDROID_PACKAGE_PLATFORM}")
+get_target_property(wagic_location wagic LOCATION)
+
+string(TOLOWER ${CMAKE_BUILD_TYPE} android_build_type)
+
+set(android_proj_target_files ${ANDROID_PROJECT_FILES})
+list_add_prefix(android_proj_target_files "${PACKAGE_DIR}/")
+set(APK_NAME "${PACKAGE_DIR}/bin/${target_name}-${android_build_type}-unsigned.apk")
+
+file(GLOB camera_wrappers "${OpenCV_SOURCE_DIR}/3rdparty/lib/${ANDROID_NDK_ABI_NAME}/libnative_camera_r*.so")
+set(CAMERA_LIB_COMMANDS "")
+
+foreach(wrapper ${camera_wrappers})
+  list(APPEND CAMERA_LIB_COMMANDS COMMAND ${CMAKE_COMMAND} -E copy "${wrapper}" "${PACKAGE_DIR}/libs/${ANDROID_NDK_ABI_NAME}/")
+endforeach()
+
+add_custom_command(
+         OUTPUT "${APK_NAME}"
+         COMMAND ${CMAKE_COMMAND} -E remove_directory "${PACKAGE_DIR}/libs"
+         COMMAND ${CMAKE_COMMAND} -E remove_directory "${PACKAGE_DIR}/bin"
+         COMMAND ${CMAKE_COMMAND} -E remove_directory "${PACKAGE_DIR}/gen"
+         COMMAND ${CMAKE_COMMAND} -E remove ${android_proj_target_files}
+         COMMAND ${CMAKE_COMMAND} -E make_directory "${PACKAGE_DIR}/src"
+         COMMAND ${CMAKE_COMMAND} -E make_directory "${PACKAGE_DIR}/libs/${ANDROID_NDK_ABI_NAME}/"
+         COMMAND ${CMAKE_COMMAND} -E copy "${SDL2_LIBRARY}" "${PACKAGE_DIR}/libs/${ANDROID_NDK_ABI_NAME}/"
+         COMMAND ${CMAKE_COMMAND} -E copy "${ZLIB_LIBRARY}" "${PACKAGE_DIR}/libs/${ANDROID_NDK_ABI_NAME}/"
+         COMMAND ${CMAKE_COMMAND} -E copy "${OPENSL_LIBRARY}" "${PACKAGE_DIR}/libs/${ANDROID_NDK_ABI_NAME}/"
+         COMMAND ${CMAKE_COMMAND} -E copy "${wagic_location}" "${PACKAGE_DIR}/libs/${ANDROID_NDK_ABI_NAME}/"
+         COMMAND ${CMAKE_COMMAND} -E copy_directory "${CMAKE_CURRENT_SOURCE_DIR}/src" "${PACKAGE_DIR}/src"
+         COMMAND ${ANDROID_EXECUTABLE} --silent update project --path "${PACKAGE_DIR}" --target "android-${ANDROID_NATIVE_API_LEVEL}" --name "${target_name}"
+         COMMAND ${ANT_EXECUTABLE} -noinput -k ${android_build_type}
+         COMMAND ${CMAKE_COMMAND} -E touch "${APK_NAME}"
+         WORKING_DIRECTORY "${PACKAGE_DIR}"
+         MAIN_DEPENDENCY "${PACKAGE_DIR}/${ANDROID_MANIFEST_FILE}"
+         DEPENDS
+         "${PACKAGE_DIR}/res/values/strings.xml" 
+         "${PACKAGE_DIR}/res/layout/main.xml"
+         "${PACKAGE_DIR}/res/drawable-mdpi/icon.png" 
+         "${PACKAGE_DIR}/res/drawable-ldpi/icon.png"
+         "${PACKAGE_DIR}/res/drawable-hdpi/icon.png"
+         "${PACKAGE_DIR}/${ANDROID_MANIFEST_FILE}"
+         wagic
+       )
+
+install(FILES "${APK_NAME}" DESTINATION "apk/" COMPONENT main)
+add_custom_target(android_package ALL SOURCES "${APK_NAME}" )
+add_dependencies(android_package wagic)

platforms/android/package/res/layout/main.xml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:orientation="vertical"
+    android:id="@+id/mainLayout"
+    android:layout_width="fill_parent"
+    android:layout_height="fill_parent"
+    >
+<TextView  
+    android:layout_width="fill_parent" 
+    android:layout_height="wrap_content" 
+    android:text="Wagic"
+    />
+</LinearLayout>
+

platforms/android/package/res/values/strings.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_name">Wagic</string>
+    <string name="app_version">0.19.2</string>
+    <string name="info_text">Wagic v0.19.2\\nAll Rights Reserved.</string>
+</resources>

platforms/android/package/src/net/wagic/utils/StorageOptions.java

@@ -0,0 +1,174 @@
+package net.wagic.utils;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.ArrayList;
+import java.util.Scanner;
+
+import android.os.Environment;
+import android.util.Log;
+
+public class StorageOptions
+{
+    private static ArrayList<String> mMounts = new ArrayList<String>();
+    private static ArrayList<String> mVold   = new ArrayList<String>();
+
+    public static String[]           labels;
+    public static String[]           paths;
+    public static int                count   = 0;
+    public static String             defaultMountPoint;
+
+    public static void determineStorageOptions()
+    {
+        initializeMountPoints();
+        readMountsFile();
+        readVoldFile();
+        compareMountsWithVold();
+        testAndCleanMountsList();
+        setProperties();
+    }
+
+    private static void initializeMountPoints()
+    {
+        try
+        {
+            defaultMountPoint = Environment.getExternalStorageDirectory().getCanonicalPath();
+        } catch (Exception ioEx)
+        {
+            // an error occurred trying to get the canonical path, use '/mnt/sdcard' instead
+            defaultMountPoint = "/mnt/sdcard";
+        }
+    }
+
+    private static void readMountsFile()
+    {
+        /*
+         * Scan the /proc/mounts file and look for lines like this: /dev/block/vold/179:1 /mnt/sdcard vfat
+         * rw,dirsync,nosuid,nodev,noexec,relatime,uid=1000,gid=1015,fmask=0602,dmask=0602,allow_utime=0020,codepage=cp437,iocharset=iso8859-1,shortname=mixed,utf8,errors=remount-ro 0 0
+         * 
+         * When one is found, split it into its elements and then pull out the path to the that mount point and add it to the arraylist
+         */
+
+        try
+        {
+            Scanner scanner = new Scanner(new File("/proc/mounts"));
+            while (scanner.hasNext())
+            {
+                String line = scanner.nextLine();
+                if (line.startsWith("/dev/block/vold/"))
+                {
+                    String[] lineElements = line.split(" ");
+                    lineElements[1].replaceAll(":.*$", "");
+                    mMounts.add(lineElements[1]);
+                }
+            }
+        } catch (FileNotFoundException fnfex)
+        {
+            // if proc/mount doesn't exist we just use
+            Log.i(StorageOptions.class.getCanonicalName(), fnfex.getMessage() + ": assuming " + defaultMountPoint + " is the only mount point");
+            mMounts.add(defaultMountPoint);
+        } catch (Exception e)
+        {
+            Log.e(StorageOptions.class.getCanonicalName(), e.getMessage() + ": unknown exception while reading mounts file");
+            mMounts.add(defaultMountPoint);
+        }
+    }
+
+    private static void readVoldFile()
+    {
+        /*
+         * Scan the /system/etc/vold.fstab file and look for lines like this: dev_mount sdcard /mnt/sdcard 1 /devices/platform/s3c-sdhci.0/mmc_host/mmc0
+         * 
+         * When one is found, split it into its elements and then pull out the path to the that mount point and add it to the arraylist
+         */
+
+        try
+        {
+            Scanner scanner = new Scanner(new File("/system/etc/vold.fstab"));
+            while (scanner.hasNext())
+            {
+                String line = scanner.nextLine();
+                if (line.startsWith("dev_mount"))
+                {
+                    String[] lineElements = line.split(" ");
+                    lineElements[2] = lineElements[2].replaceAll(":.*$", "");
+                    mVold.add(lineElements[2]);
+                }
+            }
+        } catch (FileNotFoundException fnfex)
+        {
+            // if vold.fstab doesn't exist we use the value gathered from the Environment
+            Log.i(StorageOptions.class.getCanonicalName(), fnfex.getMessage() + ": assuming " + defaultMountPoint + " is the only mount point");
+            mMounts.add(defaultMountPoint);
+        } catch (Exception e)
+        {
+            Log.e(StorageOptions.class.getCanonicalName(), e.getMessage() + ": unknown exception while reading mounts file");
+            mMounts.add(defaultMountPoint);
+        }
+    }
+
+    private static void compareMountsWithVold()
+    {
+        /*
+         * Sometimes the two lists of mount points will be different. We only want those mount points that are in both list.
+         * 
+         * Compare the two lists together and remove items that are not in both lists.
+         */
+
+        for (int i = 0; i < mMounts.size(); i++)
+        {
+            String mount = mMounts.get(i);
+            if (!mVold.contains(mount))
+                mMounts.remove(i--);
+        }
+
+        // don't need this anymore, clear the vold list to reduce memory
+        // use and to prepare it for the next time it's needed.
+        mVold.clear();
+    }
+
+    private static void testAndCleanMountsList()
+    {
+        /*
+         * Now that we have a cleaned list of mount paths Test each one to make sure it's a valid and available path. If it is not, remove it from the list.
+         */
+
+        for (int i = 0; i < mMounts.size(); i++)
+        {
+            String mount = mMounts.get(i);
+            File root = new File(mount);
+            if (!root.exists() || !root.isDirectory() || !root.canWrite())
+                mMounts.remove(i--);
+        }
+    }
+
+    private static void setProperties()
+    {
+        /*
+         * At this point all the paths in the list should be valid. Build the public properties.
+         */
+
+        ArrayList<String> mLabels = new ArrayList<String>();
+
+        int i = 1;
+        for (String path : mMounts)
+        { // TODO: /mnt/sdcard is assumed to always mean internal storage. Use this comparison until there is a better way to do this
+            if ("/mnt/sdcard".equalsIgnoreCase(path))
+                mLabels.add("Built-in Storage");
+            else
+                mLabels.add("External SD Card " + i++);
+        }
+
+        labels = new String[mLabels.size()];
+        mLabels.toArray(labels);
+
+        paths = new String[mMounts.size()];
+        mMounts.toArray(paths);
+
+        count = Math.min(labels.length, paths.length);
+
+        // don't need this anymore, clear the mounts list to reduce memory
+        // use and to prepare it for the next time it's needed.
+        mMounts.clear();
+    }
+}

platforms/android/package/src/org/libsdl/app/SDLActivity.java

@@ -0,0 +1,771 @@
+package org.libsdl.app;
+
+import java.util.Arrays;
+
+import android.app.*;
+import android.content.*;
+import android.view.*;
+import android.view.inputmethod.BaseInputConnection;
+import android.view.inputmethod.EditorInfo;
+import android.view.inputmethod.InputConnection;
+import android.view.inputmethod.InputMethodManager;
+import android.widget.AbsoluteLayout;
+import android.os.*;
+import android.util.Log;
+import android.graphics.*;
+import android.media.*;
+import android.hardware.*;
+
+
+/**
+    SDL Activity
+*/
+public class SDLActivity extends Activity {
+    private static final String TAG = "SDL";
+
+    // Keep track of the paused state
+    public static boolean mIsPaused = false, mIsSurfaceReady = false, mHasFocus = true;
+
+    // Main components
+    protected static SDLActivity mSingleton;
+    protected static SDLSurface mSurface;
+    protected static View mTextEdit;
+    protected static ViewGroup mLayout;
+
+    // This is what SDL runs in. It invokes SDL_main(), eventually
+    protected static Thread mSDLThread;
+
+    // Audio
+    protected static Thread mAudioThread;
+    protected static AudioTrack mAudioTrack;
+
+    // Load the .so
+    static {
+        System.loadLibrary("SDL2");
+        //System.loadLibrary("SDL2_image");
+        //System.loadLibrary("SDL2_mixer");
+        //System.loadLibrary("SDL2_net");
+        //System.loadLibrary("SDL2_ttf");
+        System.loadLibrary("wagic");
+    }
+
+    // Setup
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        //Log.v("SDL", "onCreate()");
+        super.onCreate(savedInstanceState);
+        
+        // So we can call stuff from static callbacks
+        mSingleton = this;
+
+        // Set up the surface
+        mSurface = new SDLSurface(getApplication());
+
+        mLayout = new AbsoluteLayout(this);
+        mLayout.addView(mSurface);
+
+        setContentView(mLayout);
+    }
+
+    // Events
+    @Override
+    protected void onPause() {
+        Log.v("SDL", "onPause()");
+        super.onPause();
+        SDLActivity.handlePause();
+    }
+
+    @Override
+    protected void onResume() {
+        Log.v("SDL", "onResume()");
+        super.onResume();
+        SDLActivity.handleResume();
+    }
+
+
+    @Override
+    public void onWindowFocusChanged(boolean hasFocus) {
+        super.onWindowFocusChanged(hasFocus);
+        Log.v("SDL", "onWindowFocusChanged(): " + hasFocus);
+
+        SDLActivity.mHasFocus = hasFocus;
+        if (hasFocus) {
+            SDLActivity.handleResume();
+        }
+    }
+
+    @Override
+    public void onLowMemory() {
+        Log.v("SDL", "onLowMemory()");
+        super.onLowMemory();
+        SDLActivity.nativeLowMemory();
+    }
+
+    @Override
+    protected void onDestroy() {
+        super.onDestroy();
+        Log.v("SDL", "onDestroy()");
+        // Send a quit message to the application
+        SDLActivity.nativeQuit();
+
+        // Now wait for the SDL thread to quit
+        if (mSDLThread != null) {
+            try {
+                mSDLThread.join();
+            } catch(Exception e) {
+                Log.v("SDL", "Problem stopping thread: " + e);
+            }
+            mSDLThread = null;
+
+            //Log.v("SDL", "Finished waiting for SDL thread");
+        }
+    }
+
+    @Override
+    public boolean dispatchKeyEvent(KeyEvent event) {
+        int keyCode = event.getKeyCode();
+        // Ignore certain special keys so they're handled by Android
+        if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN ||
+            keyCode == KeyEvent.KEYCODE_VOLUME_UP ||
+            keyCode == KeyEvent.KEYCODE_CAMERA ||
+            keyCode == 168 || /* API 11: KeyEvent.KEYCODE_ZOOM_IN */
+            keyCode == 169 /* API 11: KeyEvent.KEYCODE_ZOOM_OUT */
+            ) {
+            return false;
+        }
+        return super.dispatchKeyEvent(event);
+    }
+
+    /** Called by onPause or surfaceDestroyed. Even if surfaceDestroyed
+     *  is the first to be called, mIsSurfaceReady should still be set
+     *  to 'true' during the call to onPause (in a usual scenario).
+     */
+    public static void handlePause() {
+        if (!SDLActivity.mIsPaused && SDLActivity.mIsSurfaceReady) {
+            SDLActivity.mIsPaused = true;
+            SDLActivity.nativePause();
+            mSurface.enableSensor(Sensor.TYPE_ACCELEROMETER, false);
+        }
+    }
+
+    /** Called by onResume or surfaceCreated. An actual resume should be done only when the surface is ready.
+     * Note: Some Android variants may send multiple surfaceChanged events, so we don't need to resume
+     * every time we get one of those events, only if it comes after surfaceDestroyed
+     */
+    public static void handleResume() {
+        if (SDLActivity.mIsPaused && SDLActivity.mIsSurfaceReady && SDLActivity.mHasFocus) {
+            SDLActivity.mIsPaused = false;
+            SDLActivity.nativeResume();
+            mSurface.enableSensor(Sensor.TYPE_ACCELEROMETER, true);
+        }
+    }
+
+
+    // Messages from the SDLMain thread
+    static final int COMMAND_CHANGE_TITLE = 1;
+    static final int COMMAND_UNUSED = 2;
+    static final int COMMAND_TEXTEDIT_HIDE = 3;
+
+    protected static final int COMMAND_USER = 0x8000;
+
+    /**
+     * This method is called by SDL if SDL did not handle a message itself.
+     * This happens if a received message contains an unsupported command.
+     * Method can be overwritten to handle Messages in a different class.
+     * @param command the command of the message.
+     * @param param the parameter of the message. May be null.
+     * @return if the message was handled in overridden method.
+     */
+    protected boolean onUnhandledMessage(int command, Object param) {
+        return false;
+    }
+
+    /**
+     * A Handler class for Messages from native SDL applications.
+     * It uses current Activities as target (e.g. for the title).
+     * static to prevent implicit references to enclosing object.
+     */
+    protected static class SDLCommandHandler extends Handler {
+        @Override
+        public void handleMessage(Message msg) {
+            Context context = getContext();
+            if (context == null) {
+                Log.e(TAG, "error handling message, getContext() returned null");
+                return;
+            }
+            switch (msg.arg1) {
+            case COMMAND_CHANGE_TITLE:
+                if (context instanceof Activity) {
+                    ((Activity) context).setTitle((String)msg.obj);
+                } else {
+                    Log.e(TAG, "error handling message, getContext() returned no Activity");
+                }
+                break;
+            case COMMAND_TEXTEDIT_HIDE:
+                if (mTextEdit != null) {
+                    mTextEdit.setVisibility(View.GONE);
+
+                    InputMethodManager imm = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
+                    imm.hideSoftInputFromWindow(mTextEdit.getWindowToken(), 0);
+                }
+                break;
+
+            default:
+                if ((context instanceof SDLActivity) && !((SDLActivity) context).onUnhandledMessage(msg.arg1, msg.obj)) {
+                    Log.e(TAG, "error handling message, command is " + msg.arg1);
+                }
+            }
+        }
+    }
+
+    // Handler for the messages
+    Handler commandHandler = new SDLCommandHandler();
+
+    // Send a message from the SDLMain thread
+    boolean sendCommand(int command, Object data) {
+        Message msg = commandHandler.obtainMessage();
+        msg.arg1 = command;
+        msg.obj = data;
+        return commandHandler.sendMessage(msg);
+    }
+
+    // C functions we call
+    public static native void nativeInit();
+    public static native void nativeLowMemory();
+    public static native void nativeQuit();
+    public static native void nativePause();
+    public static native void nativeResume();
+    public static native void onNativeResize(int x, int y, int format);
+    public static native void onNativeKeyDown(int keycode);
+    public static native void onNativeKeyUp(int keycode);
+    public static native void onNativeKeyboardFocusLost();
+    public static native void onNativeTouch(int touchDevId, int pointerFingerId,
+                                            int action, float x, 
+                                            float y, float p);
+    public static native void onNativeAccel(float x, float y, float z);
+    public static native void onNativeSurfaceChanged();
+    public static native void onNativeSurfaceDestroyed();
+    public static native void nativeFlipBuffers();
+
+    public static void flipBuffers() {
+        SDLActivity.nativeFlipBuffers();
+    }
+
+    public static boolean setActivityTitle(String title) {
+        // Called from SDLMain() thread and can't directly affect the view
+        return mSingleton.sendCommand(COMMAND_CHANGE_TITLE, title);
+    }
+
+    public static boolean sendMessage(int command, int param) {
+        return mSingleton.sendCommand(command, Integer.valueOf(param));
+    }
+
+    public static Context getContext() {
+        return mSingleton;
+    }
+
+    static class ShowTextInputTask implements Runnable {
+        /*
+         * This is used to regulate the pan&scan method to have some offset from
+         * the bottom edge of the input region and the top edge of an input
+         * method (soft keyboard)
+         */
+        static final int HEIGHT_PADDING = 15;
+
+        public int x, y, w, h;
+
+        public ShowTextInputTask(int x, int y, int w, int h) {
+            this.x = x;
+            this.y = y;
+            this.w = w;
+            this.h = h;
+        }
+
+        @Override
+        public void run() {
+            AbsoluteLayout.LayoutParams params = new AbsoluteLayout.LayoutParams(
+                    w, h + HEIGHT_PADDING, x, y);
+
+            if (mTextEdit == null) {
+                mTextEdit = new DummyEdit(getContext());
+
+                mLayout.addView(mTextEdit, params);
+            } else {
+                mTextEdit.setLayoutParams(params);
+            }
+
+            mTextEdit.setVisibility(View.VISIBLE);
+            mTextEdit.requestFocus();
+
+            InputMethodManager imm = (InputMethodManager) getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
+            imm.showSoftInput(mTextEdit, 0);
+        }
+    }
+
+    public static boolean showTextInput(int x, int y, int w, int h) {
+        // Transfer the task to the main thread as a Runnable
+        return mSingleton.commandHandler.post(new ShowTextInputTask(x, y, w, h));
+    }
+            
+    public static Surface getNativeSurface() {
+        return SDLActivity.mSurface.getNativeSurface();
+    }
+
+    // Audio
+    public static int audioInit(int sampleRate, boolean is16Bit, boolean isStereo, int desiredFrames) {
+        int channelConfig = isStereo ? AudioFormat.CHANNEL_CONFIGURATION_STEREO : AudioFormat.CHANNEL_CONFIGURATION_MONO;
+        int audioFormat = is16Bit ? AudioFormat.ENCODING_PCM_16BIT : AudioFormat.ENCODING_PCM_8BIT;
+        int frameSize = (isStereo ? 2 : 1) * (is16Bit ? 2 : 1);
+        
+        Log.v("SDL", "SDL audio: wanted " + (isStereo ? "stereo" : "mono") + " " + (is16Bit ? "16-bit" : "8-bit") + " " + (sampleRate / 1000f) + "kHz, " + desiredFrames + " frames buffer");
+        
+        // Let the user pick a larger buffer if they really want -- but ye
+        // gods they probably shouldn't, the minimums are horrifyingly high
+        // latency already
+        desiredFrames = Math.max(desiredFrames, (AudioTrack.getMinBufferSize(sampleRate, channelConfig, audioFormat) + frameSize - 1) / frameSize);
+        
+        if (mAudioTrack == null) {
+            mAudioTrack = new AudioTrack(AudioManager.STREAM_MUSIC, sampleRate,
+                    channelConfig, audioFormat, desiredFrames * frameSize, AudioTrack.MODE_STREAM);
+            
+            // Instantiating AudioTrack can "succeed" without an exception and the track may still be invalid
+            // Ref: https://android.googlesource.com/platform/frameworks/base/+/refs/heads/master/media/java/android/media/AudioTrack.java
+            // Ref: http://developer.android.com/reference/android/media/AudioTrack.html#getState()
+            
+            if (mAudioTrack.getState() != AudioTrack.STATE_INITIALIZED) {
+                Log.e("SDL", "Failed during initialization of Audio Track");
+                mAudioTrack = null;
+                return -1;
+            }
+            
+            mAudioTrack.play();
+        }
+       
+        Log.v("SDL", "SDL audio: got " + ((mAudioTrack.getChannelCount() >= 2) ? "stereo" : "mono") + " " + ((mAudioTrack.getAudioFormat() == AudioFormat.ENCODING_PCM_16BIT) ? "16-bit" : "8-bit") + " " + (mAudioTrack.getSampleRate() / 1000f) + "kHz, " + desiredFrames + " frames buffer");
+        
+        return 0;
+    }
+    
+    public static void audioWriteShortBuffer(short[] buffer) {
+        for (int i = 0; i < buffer.length; ) {
+            int result = mAudioTrack.write(buffer, i, buffer.length - i);
+            if (result > 0) {
+                i += result;
+            } else if (result == 0) {
+                try {
+                    Thread.sleep(1);
+                } catch(InterruptedException e) {
+                    // Nom nom
+                }
+            } else {
+                Log.w("SDL", "SDL audio: error return from write(short)");
+                return;
+            }
+        }
+    }
+    
+    public static void audioWriteByteBuffer(byte[] buffer) {
+        for (int i = 0; i < buffer.length; ) {
+            int result = mAudioTrack.write(buffer, i, buffer.length - i);
+            if (result > 0) {
+                i += result;
+            } else if (result == 0) {
+                try {
+                    Thread.sleep(1);
+                } catch(InterruptedException e) {
+                    // Nom nom
+                }
+            } else {
+                Log.w("SDL", "SDL audio: error return from write(byte)");
+                return;
+            }
+        }
+    }
+
+    public static void audioQuit() {
+        if (mAudioTrack != null) {
+            mAudioTrack.stop();
+            mAudioTrack = null;
+        }
+    }
+
+    // Input
+
+    /**
+     * @return an array which may be empty but is never null.
+     */
+    public static int[] inputGetInputDeviceIds(int sources) {
+        int[] ids = InputDevice.getDeviceIds();
+        int[] filtered = new int[ids.length];
+        int used = 0;
+        for (int i = 0; i < ids.length; ++i) {
+            InputDevice device = InputDevice.getDevice(ids[i]);
+            if ((device != null) && ((device.getSources() & sources) != 0)) {
+                filtered[used++] = device.getId();
+            }
+        }
+        return Arrays.copyOf(filtered, used);
+    }
+}
+
+/**
+    Simple nativeInit() runnable
+*/
+class SDLMain implements Runnable {
+    @Override
+    public void run() {
+        // Runs SDL_main()
+        SDLActivity.nativeInit();
+
+        //Log.v("SDL", "SDL thread terminated");
+    }
+}
+
+
+/**
+    SDLSurface. This is what we draw on, so we need to know when it's created
+    in order to do anything useful. 
+
+    Because of this, that's where we set up the SDL thread
+*/
+class SDLSurface extends SurfaceView implements SurfaceHolder.Callback, 
+    View.OnKeyListener, View.OnTouchListener, SensorEventListener  {
+
+    // Sensors
+    protected static SensorManager mSensorManager;
+    protected static Display mDisplay;
+
+    // Keep track of the surface size to normalize touch events
+    protected static float mWidth, mHeight;
+
+    // Startup    
+    public SDLSurface(Context context) {
+        super(context);
+        getHolder().addCallback(this); 
+    
+        setFocusable(true);
+        setFocusableInTouchMode(true);
+        requestFocus();
+        setOnKeyListener(this); 
+        setOnTouchListener(this);   
+
+        mDisplay = ((WindowManager)context.getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay();
+        mSensorManager = (SensorManager)context.getSystemService(Context.SENSOR_SERVICE);
+
+        // Some arbitrary defaults to avoid a potential division by zero
+        mWidth = 1.0f;
+        mHeight = 1.0f;
+    }
+    
+    public Surface getNativeSurface() {
+        return getHolder().getSurface();
+    }
+
+    // Called when we have a valid drawing surface
+    @Override
+    public void surfaceCreated(SurfaceHolder holder) {
+        Log.v("SDL", "surfaceCreated()");
+        holder.setType(SurfaceHolder.SURFACE_TYPE_GPU);
+    }
+
+    // Called when we lose the surface
+    @Override
+    public void surfaceDestroyed(SurfaceHolder holder) {
+        Log.v("SDL", "surfaceDestroyed()");
+        // Call this *before* setting mIsSurfaceReady to 'false'
+        SDLActivity.handlePause();
+        SDLActivity.mIsSurfaceReady = false;
+        SDLActivity.onNativeSurfaceDestroyed();
+    }
+
+    // Called when the surface is resized
+    @Override
+    public void surfaceChanged(SurfaceHolder holder,
+                               int format, int width, int height) {
+        Log.v("SDL", "surfaceChanged()");
+
+        int sdlFormat = 0x15151002; // SDL_PIXELFORMAT_RGB565 by default
+        switch (format) {
+        case PixelFormat.A_8:
+            Log.v("SDL", "pixel format A_8");
+            break;
+        case PixelFormat.LA_88:
+            Log.v("SDL", "pixel format LA_88");
+            break;
+        case PixelFormat.L_8:
+            Log.v("SDL", "pixel format L_8");
+            break;
+        case PixelFormat.RGBA_4444:
+            Log.v("SDL", "pixel format RGBA_4444");
+            sdlFormat = 0x15421002; // SDL_PIXELFORMAT_RGBA4444
+            break;
+        case PixelFormat.RGBA_5551:
+            Log.v("SDL", "pixel format RGBA_5551");
+            sdlFormat = 0x15441002; // SDL_PIXELFORMAT_RGBA5551
+            break;
+        case PixelFormat.RGBA_8888:
+            Log.v("SDL", "pixel format RGBA_8888");
+            sdlFormat = 0x16462004; // SDL_PIXELFORMAT_RGBA8888
+            break;
+        case PixelFormat.RGBX_8888:
+            Log.v("SDL", "pixel format RGBX_8888");
+            sdlFormat = 0x16261804; // SDL_PIXELFORMAT_RGBX8888
+            break;
+        case PixelFormat.RGB_332:
+            Log.v("SDL", "pixel format RGB_332");
+            sdlFormat = 0x14110801; // SDL_PIXELFORMAT_RGB332
+            break;
+        case PixelFormat.RGB_565:
+            Log.v("SDL", "pixel format RGB_565");
+            sdlFormat = 0x15151002; // SDL_PIXELFORMAT_RGB565
+            break;
+        case PixelFormat.RGB_888:
+            Log.v("SDL", "pixel format RGB_888");
+            // Not sure this is right, maybe SDL_PIXELFORMAT_RGB24 instead?
+            sdlFormat = 0x16161804; // SDL_PIXELFORMAT_RGB888
+            break;
+        default:
+            Log.v("SDL", "pixel format unknown " + format);
+            break;
+        }
+
+        mWidth = width;
+        mHeight = height;
+        SDLActivity.onNativeResize(width, height, sdlFormat);
+        Log.v("SDL", "Window size:" + width + "x"+height);
+
+        // Set mIsSurfaceReady to 'true' *before* making a call to handleResume
+        SDLActivity.mIsSurfaceReady = true;
+        SDLActivity.onNativeSurfaceChanged();
+
+
+        if (SDLActivity.mSDLThread == null) {
+            // This is the entry point to the C app.
+            // Start up the C app thread and enable sensor input for the first time
+
+            SDLActivity.mSDLThread = new Thread(new SDLMain(), "SDLThread");
+            enableSensor(Sensor.TYPE_ACCELEROMETER, true);
+            SDLActivity.mSDLThread.start();
+        }
+    }
+
+    // unused
+    @Override
+    public void onDraw(Canvas canvas) {}
+
+
+    // Key events
+    @Override
+    public boolean onKey(View  v, int keyCode, KeyEvent event) {
+        
+        if (event.getAction() == KeyEvent.ACTION_DOWN) {
+            //Log.v("SDL", "key down: " + keyCode);
+            SDLActivity.onNativeKeyDown(keyCode);
+            return true;
+        }
+        else if (event.getAction() == KeyEvent.ACTION_UP) {
+            //Log.v("SDL", "key up: " + keyCode);
+            SDLActivity.onNativeKeyUp(keyCode);
+            return true;
+        }
+        
+        return false;
+    }
+
+    // Touch events
+    @Override
+    public boolean onTouch(View v, MotionEvent event) {
+             final int touchDevId = event.getDeviceId();
+             final int pointerCount = event.getPointerCount();
+             // touchId, pointerId, action, x, y, pressure
+             int actionPointerIndex = (event.getAction() & MotionEvent.ACTION_POINTER_ID_MASK) >> MotionEvent.ACTION_POINTER_ID_SHIFT; /* API 8: event.getActionIndex(); */
+             int pointerFingerId = event.getPointerId(actionPointerIndex);
+             int action = (event.getAction() & MotionEvent.ACTION_MASK); /* API 8: event.getActionMasked(); */
+
+             float x = event.getX(actionPointerIndex) / mWidth;
+             float y = event.getY(actionPointerIndex) / mHeight;
+             float p = event.getPressure(actionPointerIndex);
+
+             if (action == MotionEvent.ACTION_MOVE && pointerCount > 1) {
+                // TODO send motion to every pointer if its position has
+                // changed since prev event.
+                for (int i = 0; i < pointerCount; i++) {
+                    pointerFingerId = event.getPointerId(i);
+                    x = event.getX(i) / mWidth;
+                    y = event.getY(i) / mHeight;
+                    p = event.getPressure(i);
+                    SDLActivity.onNativeTouch(touchDevId, pointerFingerId, action, x, y, p);
+                }
+             } else {
+                SDLActivity.onNativeTouch(touchDevId, pointerFingerId, action, x, y, p);
+             }
+      return true;
+   } 
+
+    // Sensor events
+    public void enableSensor(int sensortype, boolean enabled) {
+        // TODO: This uses getDefaultSensor - what if we have >1 accels?
+        if (enabled) {
+            mSensorManager.registerListener(this, 
+                            mSensorManager.getDefaultSensor(sensortype), 
+                            SensorManager.SENSOR_DELAY_GAME, null);
+        } else {
+            mSensorManager.unregisterListener(this, 
+                            mSensorManager.getDefaultSensor(sensortype));
+        }
+    }
+    
+    @Override
+    public void onAccuracyChanged(Sensor sensor, int accuracy) {
+        // TODO
+    }
+
+    @Override
+    public void onSensorChanged(SensorEvent event) {
+        if (event.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
+            float x, y;
+            switch (mDisplay.getRotation()) {
+                case Surface.ROTATION_90:
+                    x = -event.values[1];
+                    y = event.values[0];
+                    break;
+                case Surface.ROTATION_270:
+                    x = event.values[1];
+                    y = -event.values[0];
+                    break;
+                case Surface.ROTATION_180:
+                    x = -event.values[1];
+                    y = -event.values[0];
+                    break;
+                default:
+                    x = event.values[0];
+                    y = event.values[1];
+                    break;
+            }
+            SDLActivity.onNativeAccel(-x / SensorManager.GRAVITY_EARTH,
+                                      y / SensorManager.GRAVITY_EARTH,
+                                      event.values[2] / SensorManager.GRAVITY_EARTH - 1);
+        }
+    }
+    
+}
+
+/* This is a fake invisible editor view that receives the input and defines the
+ * pan&scan region
+ */
+class DummyEdit extends View implements View.OnKeyListener {
+    InputConnection ic;
+
+    public DummyEdit(Context context) {
+        super(context);
+        setFocusableInTouchMode(true);
+        setFocusable(true);
+        setOnKeyListener(this);
+    }
+
+    @Override
+    public boolean onCheckIsTextEditor() {
+        return true;
+    }
+
+    @Override
+    public boolean onKey(View v, int keyCode, KeyEvent event) {
+
+        // This handles the hardware keyboard input
+        if (event.isPrintingKey()) {
+            if (event.getAction() == KeyEvent.ACTION_DOWN) {
+                ic.commitText(String.valueOf((char) event.getUnicodeChar()), 1);
+            }
+            return true;
+        }
+
+        if (event.getAction() == KeyEvent.ACTION_DOWN) {
+            SDLActivity.onNativeKeyDown(keyCode);
+            return true;
+        } else if (event.getAction() == KeyEvent.ACTION_UP) {
+            SDLActivity.onNativeKeyUp(keyCode);
+            return true;
+        }
+
+        return false;
+    }
+        
+    //
+    @Override
+    public boolean onKeyPreIme (int keyCode, KeyEvent event) {
+        // As seen on StackOverflow: http://stackoverflow.com/questions/7634346/keyboard-hide-event
+        // FIXME: Discussion at http://bugzilla.libsdl.org/show_bug.cgi?id=1639
+        // FIXME: This is not a 100% effective solution to the problem of detecting if the keyboard is showing or not
+        // FIXME: A more effective solution would be to change our Layout from AbsoluteLayout to Relative or Linear
+        // FIXME: And determine the keyboard presence doing this: http://stackoverflow.com/questions/2150078/how-to-check-visibility-of-software-keyboard-in-android
+        // FIXME: An even more effective way would be if Android provided this out of the box, but where would the fun be in that :)
+        if (event.getAction()==KeyEvent.ACTION_UP && keyCode == KeyEvent.KEYCODE_BACK) {
+            if (SDLActivity.mTextEdit != null && SDLActivity.mTextEdit.getVisibility() == View.VISIBLE) {
+                SDLActivity.onNativeKeyboardFocusLost();
+            }
+        }
+        return super.onKeyPreIme(keyCode, event);
+    }
+
+    @Override
+    public InputConnection onCreateInputConnection(EditorInfo outAttrs) {
+        ic = new SDLInputConnection(this, true);
+
+        outAttrs.imeOptions = EditorInfo.IME_FLAG_NO_EXTRACT_UI
+                | 33554432 /* API 11: EditorInfo.IME_FLAG_NO_FULLSCREEN */;
+
+        return ic;
+    }
+}
+
+class SDLInputConnection extends BaseInputConnection {
+
+    public SDLInputConnection(View targetView, boolean fullEditor) {
+        super(targetView, fullEditor);
+
+    }
+
+    @Override
+    public boolean sendKeyEvent(KeyEvent event) {
+
+        /*
+         * This handles the keycodes from soft keyboard (and IME-translated
+         * input from hardkeyboard)
+         */
+        int keyCode = event.getKeyCode();
+        if (event.getAction() == KeyEvent.ACTION_DOWN) {
+            if (event.isPrintingKey()) {
+                commitText(String.valueOf((char) event.getUnicodeChar()), 1);
+            }
+            SDLActivity.onNativeKeyDown(keyCode);
+            return true;
+        } else if (event.getAction() == KeyEvent.ACTION_UP) {
+
+            SDLActivity.onNativeKeyUp(keyCode);
+            return true;
+        }
+        return super.sendKeyEvent(event);
+    }
+
+    @Override
+    public boolean commitText(CharSequence text, int newCursorPosition) {
+
+        nativeCommitText(text.toString(), newCursorPosition);
+
+        return super.commitText(text, newCursorPosition);
+    }
+
+    @Override
+    public boolean setComposingText(CharSequence text, int newCursorPosition) {
+
+        nativeSetComposingText(text.toString(), newCursorPosition);
+
+        return super.setComposingText(text, newCursorPosition);
+    }
+
+    public native void nativeCommitText(String text, int newCursorPosition);
+
+    public native void nativeSetComposingText(String text, int newCursorPosition);
+
+}
+

platforms/psp/configure.cmake

@@ -0,0 +1,5 @@
+add_definitions(-DPSP -G0)
+add_definitions(-D_PSP_FW_VERSION=371)
+add_definitions(-DDEVHOOK -DPSPFW3XX) 
+
+include_directories(${PSPSDK_PATH}/include)

platforms/unix/configure.cmake

@@ -0,0 +1,3 @@
+add_definitions(-DLINUX)
+add_definitions(-DUSERDIR=".wagic") 
+add_definitions(-DRESDIR="Res")

platforms/win32/configure.cmake

@@ -0,0 +1,2 @@
+add_definitions(-DWIN32)
+add_definitions(COMPILE_DEFINITIONS_DEBUG _CRT_SECURE_NO_WARNINGS) 

projects/mtg/CMakeLists.txt

@@ -0,0 +1,226 @@
+#MTGs common sources
+set(MTG_generic_src         
+        src/AbilityParser.cpp
+        src/ActionElement.cpp
+        src/ActionLayer.cpp
+        src/ActionStack.cpp
+        src/AIHints.cpp
+        src/AIMomirPlayer.cpp
+        src/AIPlayer.cpp
+        src/AIPlayerBaka.cpp
+        src/AIStats.cpp
+        src/AllAbilities.cpp
+        src/CardDescriptor.cpp
+        src/CardDisplay.cpp
+        src/CardGui.cpp
+        src/CardPrimitive.cpp
+        src/CardSelector.cpp
+        src/CardSelectorSingleton.cpp
+        src/CarouselDeckView.cpp
+        src/Closest.cpp
+        src/Counters.cpp
+        src/Credits.cpp
+        src/Damage.cpp
+        src/DamagerDamaged.cpp
+        src/DeckDataWrapper.cpp
+        src/DeckEditorMenu.cpp
+        src/DeckManager.cpp
+        src/DeckMenu.cpp
+        src/DeckMenuItem.cpp
+        src/DeckMetaData.cpp
+        src/DeckStats.cpp
+        src/DeckView.cpp
+        src/DuelLayers.cpp
+        src/ExtraCost.cpp
+        src/GameApp.cpp
+        src/GameLauncher.cpp
+        src/GameObserver.cpp
+        src/GameOptions.cpp
+        src/GameStateAwards.cpp
+        src/GameState.cpp
+        src/GameStateDeckViewer.cpp
+        src/GameStateDuel.cpp
+        src/GameStateMenu.cpp
+        src/GameStateOptions.cpp
+        src/GameStateShop.cpp
+        src/GameStateStory.cpp
+        src/GameStateTransitions.cpp
+        src/GridDeckView.cpp
+        src/GuiAvatars.cpp
+        src/GuiBackground.cpp
+        src/GuiCardsController.cpp
+        src/GuiCombat.cpp
+        src/GuiFrame.cpp
+        src/GuiHand.cpp
+        src/GuiLayers.cpp
+        src/GuiMana.cpp
+        src/GuiPhaseBar.cpp
+        src/GuiPlay.cpp
+        src/GuiStatic.cpp
+        src/IconButton.cpp
+        src/InteractiveButton.cpp
+        src/ManaCost.cpp
+        src/ManaCostHybrid.cpp
+        src/MenuItem.cpp
+        src/ModRules.cpp
+        src/MTGAbility.cpp
+        src/MTGCard.cpp
+        src/MTGCardInstance.cpp
+        src/MTGDeck.cpp
+        src/MTGDefinitions.cpp
+        src/MTGGamePhase.cpp
+        src/MTGGameZones.cpp
+        src/MTGPack.cpp
+        src/MTGRules.cpp
+        src/ObjectAnalytics.cpp
+        src/OptionItem.cpp
+        src/PhaseRing.cpp
+        src/Player.cpp
+        src/PlayerData.cpp
+        src/PlayGuiObject.cpp
+        src/PlayGuiObjectController.cpp
+        src/PlayRestrictions.cpp
+        src/Pos.cpp
+        src/PriceList.cpp
+        src/ReplacementEffects.cpp
+        src/Rules.cpp
+        src/SimpleMenu.cpp
+        src/SimpleMenuItem.cpp
+        src/SimpleButton.cpp
+        src/SimplePad.cpp
+        src/SimplePopup.cpp
+        src/StoryFlow.cpp
+        src/Subtypes.cpp
+        src/StyleManager.cpp
+        src/TargetChooser.cpp
+        src/TargetsList.cpp
+        src/Tasks.cpp
+        src/TextScroller.cpp
+        src/ThisDescriptor.cpp
+        src/Token.cpp
+        src/Translate.cpp
+        src/TranslateKeys.cpp
+        src/Trash.cpp
+        src/utils.cpp
+        src/WCachedResource.cpp
+        src/WDataSrc.cpp
+        src/WEvent.cpp
+        src/WFilter.cpp
+        src/WFont.cpp
+        src/WGui.cpp
+        src/WResourceManager.cpp
+        src/NetworkPlayer.cpp
+        )
+
+#the sources we need if we compile a graphical qt version
+#TODO: add declarative version since this only works with QWidget right now
+set(MTG_qt_graphic_src
+        src/qt/filedownloader.cpp
+        src/qt/corewrapper.cpp
+        include/qt/corewrapper.h #so automoc finds it
+        include/qt/filedownloader.h
+        src/Qtmain.cpp)
+
+#the sources we need to compile the testsuit
+set(MTG_qt_console_src
+        src/Qtconsole.cpp
+        src/TestSuiteAI.cpp)
+        
+set(MTG_sdl_src
+        src/SDLmain.cpp)
+        
+set(MTG_android_sdl_src
+        src/SDLmain.cpp
+        src/SDL_android_main.cpp)
+
+
+set(MTG_INCLUDE_DIRS include include/qt)
+set(JGE_INCLUDE_DIRS ../../JGE/include ../../JGE/include/hge)
+set(JGE_LIBRARY jge)
+    
+#turn moc on
+if(backend_qt_console OR backend_qt_widget)
+    set(CMAKE_INCLUDE_CURRENT_DIR ON)
+    set(CMAKE_AUTOMOC TRUE)
+endif()
+
+if(backend_qt_console)
+    if(UNIX AND NOT ANDROID)
+        include_directories(${MTG_INCLUDE_DIRS} ${JGE_INCLUDE_DIRS} ${ZIPFS_INCLUDE_DIR} ${Qt5Core_INCLUDE_DIRS} ${Qt5Multimedia_INCLUDE_DIRS}
+            ${UNZIP_INCLUDE_DIR} ${HGE_INCLUDE_DIR} ${TINYXML_INCLUDE_DIR} ${QT_MKSPECS_DIR}/default)
+        add_executable(wagic ${MTG_generic_src} ${MTG_qt_console_src})
+        target_link_libraries(wagic  ${JGE_LIBRARY} ${Qt5Core_INCLUDE_DIRS} ${Qt5Multimedia_INCLUDE_DIRS} ${TINYXML_LIBRARIES}
+            ${HGE_LIBRARY})
+    else()
+        message(FATAL_ERROR "qt-console bilds are only supported on unix platforms")
+    endif()
+endif()
+
+if(backend_qt_widget)
+    if(UNIX AND NOT ANDROID)
+        include_directories(${MTG_INCLUDE_DIRS} ${JGE_INCLUDE_DIRS} ${ZIPFS_INCLUDE_DIR} ${Qt5Core_INCLUDE_DIRS} ${Qt5Multimedia_INCLUDE_DIRS}
+            ${UNZIP_INCLUDE_DIR} ${HGE_INCLUDE_DIR} ${TINYXML_INCLUDE_DIR} ${QT_MKSPECS_DIR}/default)
+        add_executable(wagic ${MTG_generic_src} ${MTG_qt_graphic_src})
+        target_link_libraries(wagic  ${JGE_LIBRARY} ${Qt5Core_INCLUDE_DIRS} ${Qt5Multimedia_INCLUDE_DIRS} ${OPENGL_LIBRARIES} ${TINYXML_LIBRARIES}
+            ${HGE_LIBRARY})# ${X11_LIBRARIES})
+    else()
+        message(FATAL_ERROR "qt-widget bilds are only supported on unix platforms")
+    endif()
+endif()
+
+if(backend_sdl)
+    if(UNIX AND NOT ANDROID)
+        include_directories(${MTG_INCLUDE_DIRS} ${JGE_INCLUDE_DIRS} ${SDL2_INCLUDE_DIR} ${ZIPFS_INCLUDE_DIR} 
+            ${BOOST_INCLUDE_DIRS} ${UNZIP_INCLUDE_DIR} ${HGE_INCLUDE_DIR} ${TINYXML_INCLUDE_DIR})
+        add_executable(wagic ${MTG_generic_src} ${MTG_sdl_src})
+        target_link_libraries(wagic  ${JGE_LIBRARY} ${SDL2_LIBRARY} ${OPENGL_LIBRARIES} ${TINYXML_LIBRARIES} 
+            ${Boost_LIBRARIES} ${HGE_LIBRARY})
+    elseif(ANDROID)
+        include_directories(${MTG_INCLUDE_DIRS} ${JGE_INCLUDE_DIRS} ${SDL2_INCLUDE_DIR} ${ZIPFS_INCLUDE_DIR} 
+            ${BOOST_INCLUDE_DIRS} ${UNZIP_INCLUDE_DIR} ${HGE_INCLUDE_DIR} ${TINYXML_INCLUDE_DIR})
+        #we should try to get rid of this hack
+        add_library(wagic SHARED ${MTG_generic_src} ${MTG_android_sdl_src}
+                    ${ANDROID_BOOST_PTHREAD_SRC_DIR}/thread.cpp
+                    ${ANDROID_BOOST_PTHREAD_SRC_DIR}/once.cpp
+                    ${ANDROID_BOOST_SYSTEM_SRC_DIR}/error_code.cpp
+                    src/TestSuiteAI.cpp)
+        target_link_libraries(wagic  ${JGE_LIBRARY} ${SDL2_LIBRARY} ${OPENGL_LIBRARIES} ${TINYXML_LIBRARIES} 
+            ${HGE_LIBRARY})
+    elseif(WIN32)
+        include_directories(${MTG_INCLUDE_DIRS} ${JGE_INCLUDE_DIRS} ${SDL2_INCLUDE_DIR} ${ZIPFS_INCLUDE_DIR} 
+            ${Boost_INCLUDE_DIR} ${UNZIP_INCLUDE_DIR} ${HGE_INCLUDE_DIR} ${TINYXML_INCLUDE_DIR} 
+            ${ZLIB_INCLUDE_DIR})
+        add_executable(wagic ${MTG_generic_src} ${MTG_sdl_src} src/TestSuiteAI.cpp src/AIPlayerBakaB.cpp)
+        link_directories(${Boost_LIBRARY_DIR} ${SDL2_LIBRARY_DIR})
+        target_link_libraries(wagic  ${JGE_LIBRARY} ${SDL2_LIBRARY} ${OPENGL_LIBRARIES} ${TINYXML_LIBRARIES} 
+            ${BOOST_date_time} ${HGE_LIBRARY} ${CMAKE_SOURCE_DIR}/thirdparty/binary/win/lib/fmodvc.lib)
+    endif()
+endif()
+
+if(backend_psp)
+    if(PSP)
+        #${PSPSDK_PATH}/include
+        include_directories(${MTG_INCLUDE_DIRS} ${JGE_INCLUDE_DIRS} ${TINYXML_INCLUDE_DIR} ${ZIPFS_INCLUDE_DIR} 
+            ${UNZIP_INCLUDE_DIR} ${BOOST_INCLUDE_DIRS} ${GIF_INCLUDE_DIR} ${HGETOOLS_INCLUDE_DIRS})
+        add_executable(wagic ${MTG_generic_src})
+        target_link_libraries(wagic ${JGE_LIBRARY} ${PSPSDK_LIB} ${HGETOOLS_LIBRARY} ${FREETYPE_LIB} ${JPEG_LIBRARY} 
+            ${GIF_LIBRARIES} ${PNG_LIBRARIES} z m ${MIKMOD_LIBRARY} ${TINYXML_LIBRARIES} 
+            stdc++ ${PSPSDK_REQUIRED_LIB})
+
+        set(PRXSPECS_FILE "${PSPSDK_PATH}/lib/prxspecs")
+        set(LINKFILE_FILE "${PSPSDK_PATH}/lib/linkfile.prx")
+
+        get_property(wagic_elf_location TARGET wagic PROPERTY LOCATION)
+        get_filename_component(wagic_elf_directory ${wagic_elf_location} PATH)
+
+        set_target_properties(wagic PROPERTIES LINK_FLAGS "-specs=${PRXSPECS_FILE} -Wl,-q,-T${LINKFILE_FILE}")
+        
+        add_custom_command(TARGET wagic POST_BUILD
+            COMMAND ${PSPSDK_MKSFO_COMMAND} ARGS "'Wagic, the Homebrew?!'" "${wagic_elf_directory}/PARAM.SFO"
+            COMMAND ${PSPSDK_FIXUP_IMPORTS_COMMAND} ARGS ${wagic_elf_location}
+            COMMAND ${PSPSDK_PRXGEN_COMMAND} ARGS ${wagic_elf_location} "${wagic_elf_directory}/wagic.prx"
+            COMMAND ${PSPSDK_PACK_PBP_COMMAND} ARGS ${wagic_elf_directory}/EBOOT.PBP ${wagic_elf_directory}/PARAM.SFO ${CMAKE_CURRENT_SOURCE_DIR}/icon.png NULL ${CMAKE_CURRENT_SOURCE_DIR}/pic0.png ${CMAKE_CURRENT_SOURCE_DIR}/pic1.png NULL "${wagic_elf_directory}/wagic.prx" NULL)
+    else()
+        message(FATAL_ERROR "use the cross-compile toolchain to build as the psp target")
+    endif()
+endif()

projects/mtg/include/StoryFlow.h

@@ -5,7 +5,7 @@
 #include <map>
 #include <vector>
 using namespace std;
-#include "../../../JGE/src/tinyxml/tinyxml.h"
+#include "tinyxml.h"
 #include <JGui.h>
 class GameObserver;
 class MTGDeck;

projects/mtg/src/MTGPack.cpp

@@ -9,7 +9,7 @@
 #include "WFilter.h"
 #include "DeckDataWrapper.h"
 #include "MTGPack.h"
-#include "../../../JGE/src/tinyxml/tinyxml.h"
+#include "tinyxml.h"
 
 MTGPack MTGPacks::defaultBooster;
 

projects/mtg/src/ModRules.cpp

@@ -3,7 +3,7 @@
 #include "ModRules.h"
 #include "utils.h"
 #include "GameState.h"
-#include "../../../JGE/src/tinyxml/tinyxml.h"
+#include "tinyxml.h"
 
 
 ModRules gModRules;

projects/mtg/src/StyleManager.cpp

@@ -7,7 +7,7 @@
 #include "DeckDataWrapper.h"
 #include "WFilter.h"
 #include "StyleManager.h"
-#include "../../../JGE/src/tinyxml/tinyxml.h"
+#include "tinyxml.h"
 
 void StyleManager::killRules()
 {