updated iOS UI issues:

* fixed status bar issue on iOS7, where status bar information was invisible on iOS7 devices
  * fixed some font issues on the Shop screens to make them more legible for iOS users. ( changed font size for Interactive Buttons and card list)
  * added new gesture for opening up the menu screen for iOS.  Since there are no external buttons on iOS devices, we need either on-screen buttons or gestures to compensate.  Using the pinch or zoom gesture will simulate pressing the "MENU" button on the PSP on all screens now.  Not ideal, but something for now until we can work in a new button or way to open up the menu.

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,38 +0,0 @@
----
-name: Bug report
-about: Create a report to help us improve
-title: ''
-labels: ''
-assignees: ''
-
----
-
-**Describe the bug**
-A clear and concise description of what the bug is.
-
-**To Reproduce**
-Steps to reproduce the behavior:
-1. Go to '...'
-2. Click on '....'
-3. Scroll down to '....'
-4. See error
-
-**Expected behavior**
-A clear and concise description of what you expected to happen.
-
-**Screenshots**
-If applicable, add screenshots to help explain your problem.
-
-**Desktop (please complete the following information):**
- - OS: [e.g. iOS]
- - Browser [e.g. chrome, safari]
- - Version [e.g. 22]
-
-**Smartphone (please complete the following information):**
- - Device: [e.g. iPhone6]
- - OS: [e.g. iOS8.1]
- - Browser [e.g. stock browser, safari]
- - Version [e.g. 22]
-
-**Additional context**
-Add any other context about the problem here.

.github/ISSUE_TEMPLATE/custom.md

@@ -1,10 +0,0 @@
----
-name: Custom issue template
-about: Describe this issue template's purpose here.
-title: ''
-labels: ''
-assignees: ''
-
----
-
-

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,20 +0,0 @@
----
-name: Feature request
-about: Suggest an idea for this project
-title: ''
-labels: ''
-assignees: ''
-
----
-
-**Is your feature request related to a problem? Please describe.**
-A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
-
-**Describe the solution you'd like**
-A clear and concise description of what you want to happen.
-
-**Describe alternatives you've considered**
-A clear and concise description of any alternative solutions or features you've considered.
-
-**Additional context**
-Add any other context or screenshots about the feature request here.

.gitmodules

@@ -1,3 +0,0 @@
-[submodule "docs/wiki"]
-	path = docs/wiki
-	url = https://github.com/WagicProject/wagic.wiki

.travis.yml

@@ -1,79 +1,17 @@
 language: cpp
-dist: xenial
-branches:
-  only:
-    - master
-
 before_install:
-  - export BUILD_PSP=YES
+  - export PSPDEV="$TRAVIS_BUILD_DIR/opt/pspsdk"
-  - export BUILD_ANDROID=YES
+  - export PSPSDK="$PSPDEV/psp/sdk"
-  - export BUILD_Qt=YES
+  - export PATH="$PATH:$PSPDEV/bin:$PSPSDK/bin"
-  - export BUILD_MAC=NO
+  - export ANDROID="android-sdk-linux/tools/android"
-  - echo -e "machine github.com\n  login $GH_TOKEN2" > ~/.netrc
-  - git lfs pull
-# Only building on Mac when not handling pull request
-# - if [ "$TRAVIS_PULL_REQUEST" ==  "false" ]; then
-#     export BUILD_MAC=YES;
-#   fi
-  - sudo apt-get update -qq
-# Building for PSP here
-  - if [ "$BUILD_PSP" == "YES" ]; then
-      export PSPDEV="$TRAVIS_BUILD_DIR/opt/pspsdk" &&
-      export PSPSDK="$PSPDEV/psp/sdk" &&
-      export PATH="$PATH:$PSPDEV/bin:$PSPSDK/bin" &&
-      wget --no-check-certificate -O sdk.lzma http://downloads.sourceforge.net/project/minpspw/SDK%20%2B%20devpak/pspsdk%200.11.2/minpspw_0.11.2-amd64.tar.lzma;
-    fi
-# Building for Qt here
-  - if [ "$BUILD_Qt" == "YES" ]; then
-      sudo add-apt-repository "deb http://archive.ubuntu.com/ubuntu xenial universe" &&
-      sudo add-apt-repository "deb http://archive.ubuntu.com/ubuntu xenial main" &&
-      sudo apt-get -qq update &&
-      sudo apt-get -qq install qt5-qmake qtbase5-dev qtdeclarative5-dev qttools5-dev qtmultimedia5-dev libqt5opengl5 libqt5opengl5-dev pulseaudio libpulse-dev &&
-      export QMAKE="qmake -qt=qt5";
-    fi
-# Building for Android here
-  - if [ "$BUILD_ANDROID" == "YES" ]; then
-      export ANDROID="android-sdk-linux/tools/android" &&
-      if [ `uname -m` = x86_64 ]; then 
-        sudo dpkg --add-architecture i386 && sudo apt-get update &&
-        sudo apt-get install -qq --force-yes libgd2-xpm-dev libc6-i386 lib32stdc++6 lib32gcc1 lib32ncurses5 lib32z1 jq ant; fi &&
-        wget https://dl.google.com/android/repository/android-ndk-r22-linux-x86_64.zip -nv &&
-        wget http://dl.google.com/android/android-sdk_r24.4.1-linux.tgz -nv;
-    fi
-    
 install:
-- if [ "$BUILD_PSP" == "YES" ]; then
+  - sudo apt-get update -qq
-    tar -x --xz -f sdk.lzma;
+  - if [ `uname -m` = x86_64 ]; then sudo apt-get install -qq --force-yes libgd2-xpm ia32-libs ia32-libs-multiarch; fi
-  fi
+  - wget -O sdk.lzma http://sourceforge.net/projects/minpspw/files/SDK%20%2B%20devpak/pspsdk%200.11.2/minpspw_0.11.2-amd64.tar.lzma/download
-- if [ "$BUILD_ANDROID" == "YES" ]; then
+  - tar -x --xz -f sdk.lzma
-    unzip android-ndk-r22-linux-x86_64.zip &&
+  - wget http://dl.google.com/android/ndk/android-ndk-r9-linux-x86_64.tar.bz2 -nv
-    tar -zxf android-sdk_r24.4.1-linux.tgz &&
+  - wget http://dl.google.com/android/android-sdk_r22-linux.tgz -nv
-    $ANDROID list sdk --extended -a &&
+  - tar --absolute-names -jxf android-ndk-r9-linux-x86_64.tar.bz2
-    echo yes | $ANDROID update sdk -a -t tools,platform-tools,build-tools-23.0.1,android-23 --no-ui --force --no-https;
+  - tar -zxf android-sdk_r22-linux.tgz
-    sudo apt-get install openjdk-8-jdk;
+  - echo yes | $ANDROID update sdk --filter 1,2,3,8 --no-ui --force > log.txt
-    export JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64;
+script: "./travis-script.sh"
-    export PATH=$JAVA_HOME/bin:$PATH;
-  fi
-
-- curl https://bootstrap.pypa.io/pip/2.7/get-pip.py -o get-pip.py
-- sudo python2 get-pip.py
-- sudo python2 -m pip install --upgrade pip
-- sudo python2 -m pip install setuptools-rust
-- sudo python2 -m pip install pyOpenSSL
-- sudo python2 -m pip install pyjavaproperties
-- sudo python2 -m pip install github3.py
-- sudo python2 -m pip install cpp-coveralls
-- sudo python2 -m pip install certifi
-
-before_script:
-- export REQUESTS_CA_BUNDLE=/usr/local/lib/python2.7/dist-packages/certifi/cacert.pem
-script: "tools/travis-script.sh"
-
-after_success:
-- coveralls -b . -e JGE/src -e JGE/include -i projects/mtg/include -i projects/mtg/src --gcov-options '\-lp'
-- export VERSION=$(grep "=" projects/mtg/build.number.properties | sed 's/.*=//' | tr -d '\n\t\r ')
-- python2 tools/upload-binaries.py -t $GH_TOKEN2 -s $TRAVIS_COMMIT -l core.zip -r Wagic-core-$VERSION.zip -b $TRAVIS_BRANCH
-- python2 tools/upload-binaries.py -t $GH_TOKEN2 -s $TRAVIS_COMMIT -l projects/mtg/Android/bin/Wagic-debug.apk -r Wagic-$VERSION.apk -b $TRAVIS_BRANCH
-- python2 tools/upload-binaries.py -t $GH_TOKEN2 -s $TRAVIS_COMMIT -l projects/mtg/psprelease.zip -r WagicPSP-$VERSION.zip -b $TRAVIS_BRANCH
-- python2 tools/upload-binaries.py -t $GH_TOKEN2 -s $TRAVIS_COMMIT -l qt-gui-build/linuxqtrelease.zip -r WagicLinux-$VERSION.zip -b $TRAVIS_BRANCH
-- python2 tools/upload-binaries.py -t $GH_TOKEN2 -s $TRAVIS_COMMIT -l projects/mtg/CardImageLinks.csv -r CardImageLinks.csv -b $TRAVIS_BRANCH

Boost/boost/smart_ptr/detail/spinlock_gcc_arm.hpp

@@ -29,30 +29,11 @@ public:
     {
         int r;
 
-        #if defined(__ARM_FEATURE_LSE)
-        // Use LSE atomic instructions if supported
-        #pragma message("LSE feature detected") // This will print a message in your build logs
         __asm__ __volatile__(
-            "ldaxr %0, [%1];"   // Load-Exclusive instruction
+            "swp %0, %1, [%2]":
-            "cbnz %0, 1f;"       // If the value is non-zero, the lock is already acquired
+            "=&r"( r ): // outputs
-            "stlxr %w0, %2, [%1];" // Store-Exclusive instruction
+            "r"( 1 ), "r"( &v_ ): // inputs
-            "cbnz %w0, 1f;"      // If the store failed, retry
+            "memory", "cc" );
-            "mov %0, #0;"        // Success, zero indicates lock acquired
-            "1:"
-            : "=&r"(r)
-            : "r"(&v_), "r"(1)
-            : "memory", "cc"
-        );
-        #else
-        // Fallback for systems that don't support LSE
-        #pragma message("LSE feature not detected") // This will print a message in your build logs if LSE is not detected
-        __asm__ __volatile__(
-            "swp %0, %1, [%2];"  // Swap instruction (used as a fallback)
-            : "=&r"(r)            // output constraint
-            : "r"(1), "r"(&v_)    // input constraints
-            : "memory", "cc"      // clobbered registers
-        );
-        #endif
 
         return r == 0;
     }

Boost/boost/thread/xtime.hpp

@@ -20,7 +20,7 @@ namespace boost {
 
 enum xtime_clock_types
 {
-    TIME_UTC_=1
+    TIME_UTC=1
 //    TIME_TAI,
 //    TIME_MONOTONIC,
 //    TIME_PROCESS,
@@ -68,7 +68,7 @@ inline xtime get_xtime(boost::system_time const& abs_time)
 
 inline int xtime_get(struct xtime* xtp, int clock_type)
 {
-    if (clock_type == TIME_UTC_)
+    if (clock_type == TIME_UTC)
     {
         *xtp=get_xtime(get_system_time());
         return clock_type;

Boost/lib/pthread/thread.cpp

@@ -350,7 +350,7 @@ namespace boost
                     cond.timed_wait(lock, xt);
 #   endif
                     xtime cur;
-                    xtime_get(&cur, TIME_UTC_);
+                    xtime_get(&cur, TIME_UTC);
                     if (xtime_cmp(xt, cur) <= 0)
                         return;
                 }
@@ -365,7 +365,7 @@ namespace boost
             BOOST_VERIFY(!pthread_yield());
 #   else
             xtime xt;
-            xtime_get(&xt, TIME_UTC_);
+            xtime_get(&xt, TIME_UTC);
             sleep(xt);
 #   endif
         }

Boost/lib/pthread/timeconv.inl

@@ -20,8 +20,8 @@ const int NANOSECONDS_PER_MICROSECOND = 1000;
 inline void to_time(int milliseconds, boost::xtime& xt)
 {
     int res = 0;
-    res = boost::xtime_get(&xt, boost::TIME_UTC_);
+    res = boost::xtime_get(&xt, boost::TIME_UTC);
-    BOOST_ASSERT(res == boost::TIME_UTC_);
+    BOOST_ASSERT(res == boost::TIME_UTC);
 
     xt.sec += (milliseconds / MILLISECONDS_PER_SECOND);
     xt.nsec += ((milliseconds % MILLISECONDS_PER_SECOND) *
@@ -57,8 +57,8 @@ inline void to_timespec_duration(const boost::xtime& xt, timespec& ts)
 {
     boost::xtime cur;
     int res = 0;
-    res = boost::xtime_get(&cur, boost::TIME_UTC_);
+    res = boost::xtime_get(&cur, boost::TIME_UTC);
-    BOOST_ASSERT(res == boost::TIME_UTC_);
+    BOOST_ASSERT(res == boost::TIME_UTC);
 
     if (boost::xtime_cmp(xt, cur) <= 0)
     {
@@ -88,8 +88,8 @@ inline void to_duration(boost::xtime xt, int& milliseconds)
 {
     boost::xtime cur;
     int res = 0;
-    res = boost::xtime_get(&cur, boost::TIME_UTC_);
+    res = boost::xtime_get(&cur, boost::TIME_UTC);
-    BOOST_ASSERT(res == boost::TIME_UTC_);
+    BOOST_ASSERT(res == boost::TIME_UTC);
 
     if (boost::xtime_cmp(xt, cur) <= 0)
         milliseconds = 0;
@@ -110,8 +110,8 @@ inline void to_microduration(boost::xtime xt, int& microseconds)
 {
     boost::xtime cur;
     int res = 0;
-    res = boost::xtime_get(&cur, boost::TIME_UTC_);
+    res = boost::xtime_get(&cur, boost::TIME_UTC);
-    BOOST_ASSERT(res == boost::TIME_UTC_);
+    BOOST_ASSERT(res == boost::TIME_UTC);
 
     if (boost::xtime_cmp(xt, cur) <= 0)
         microseconds = 0;

JGE/Dependencies/SDL/src/atomic/SDL_spinlock.c

@@ -14,11 +14,10 @@
      claim that you wrote the original software. If you use this software
      in a product, an acknowledgment in the product documentation would be
      appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not
+  2. Altered source versions must be plainly marked as such, and must not be
-     be misrepresented as being the original software.
+     misrepresented as being the original software.
   3. This notice may not be removed or altered from any source distribution.
 */
-
 #include "SDL_stdinc.h"
 
 #include "SDL_atomic.h"
@@ -31,7 +30,8 @@
 #endif
 
 /* This function is where all the magic happens... */
-SDL_bool SDL_AtomicTryLock(SDL_SpinLock *lock)
+SDL_bool
+SDL_AtomicTryLock(SDL_SpinLock *lock)
 {
 #if SDL_ATOMIC_DISABLED
     /* Terrible terrible damage */
@@ -77,35 +77,14 @@ SDL_bool SDL_AtomicTryLock(SDL_SpinLock *lock)
         : "=&r" (result) : "r" (1), "r" (lock) : "cc", "memory");
     return (result == 0);
 
-#elif defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
-    int result;
-    __asm__ __volatile__(
-        "lock ; xchgl %0, (%1)\n"
-        : "=r" (result) : "r" (lock), "0" (1) : "cc", "memory");
-    return (result == 0);
-
 #else
-    /* Fallback implementation using a standard mutex */
+    /* Need CPU instructions for spinlock here! */
-    /* You can use SDL_mutex as a fallback if no atomic instructions are available */
+    __need_spinlock_implementation__
-    static SDL_mutex *mutex;
-    if (!mutex) {
-        mutex = SDL_CreateMutex();
-    }
-
-    SDL_mutexP(mutex);
-    if (*lock == 0) {
-        *lock = 1;
-        SDL_mutexV(mutex);
-        return SDL_TRUE;
-    } else {
-        SDL_mutexV(mutex);
-        return SDL_FALSE;
-    }
-
 #endif
 }
 
-void SDL_AtomicLock(SDL_SpinLock *lock)
+void
+SDL_AtomicLock(SDL_SpinLock *lock)
 {
     /* FIXME: Should we have an eventual timeout? */
     while (!SDL_AtomicTryLock(lock)) {
@@ -113,7 +92,8 @@ void SDL_AtomicLock(SDL_SpinLock *lock)
     }
 }
 
-void SDL_AtomicUnlock(SDL_SpinLock *lock)
+void
+SDL_AtomicUnlock(SDL_SpinLock *lock)
 {
 #if defined(_MSC_VER)
     _ReadWriteBarrier();

JGE/Dependencies/lib/SDL.dll.intermediate.manifest

@@ -1,10 +0,0 @@
-<?xml version='1.0' encoding='UTF-8' standalone='yes'?>
-<assembly xmlns='urn:schemas-microsoft-com:asm.v1' manifestVersion='1.0'>
-  <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
-    <security>
-      <requestedPrivileges>
-        <requestedExecutionLevel level='asInvoker' uiAccess='false' />
-      </requestedPrivileges>
-    </security>
-  </trustInfo>
-</assembly>

JGE/Dependencies/libpng/png.h

@@ -474,7 +474,7 @@
 
 #ifndef PNG_VERSION_INFO_ONLY
 /* include the compression library's header */
-#include "../include/zlib.h"
+#include "zlib.h"
 #endif
 
 /* include all user configurable info, including optional assembler routines */

JGE/JGE.vcxproj

@@ -73,7 +73,7 @@
       <Optimization>MaxSpeed</Optimization>
       <InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
       <AdditionalIncludeDirectories>src/zipFS;Dependencies/SDL/include;Dependencies/include;$(JGEEXTRAS);../Boost;../projects/mtg/include;include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>TIXML_USE_STL; SDL_CONFIG;WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>SDL_CONFIG;WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <StringPooling>true</StringPooling>
       <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
       <FunctionLevelLinking>true</FunctionLevelLinking>
@@ -101,7 +101,7 @@
     <ClCompile>
       <Optimization>Disabled</Optimization>
       <AdditionalIncludeDirectories>src/zipFS;Dependencies/SDL/include;Dependencies/include;$(JGEEXTRAS);../Boost;../projects/mtg/include;include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>TIXML_USE_STL; SDL_CONFIG;WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>SDL_CONFIG;WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
       <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
       <PrecompiledHeader>
@@ -129,7 +129,7 @@
       <Optimization>Full</Optimization>
       <InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
       <AdditionalIncludeDirectories>src/zipFS;Dependencies/SDL/include;Dependencies/include;$(JGEEXTRAS);../Boost;../projects/mtg/include;include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>TIXML_USE_STL; SDL_CONFIG;WIN32;NDEBUG;_LIB;_SECURE_SCL=0;_HAS_ITERATOR_DEBBUGING=0;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>SDL_CONFIG;WIN32;NDEBUG;_LIB;_SECURE_SCL=0;_HAS_ITERATOR_DEBBUGING=0;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <StringPooling>true</StringPooling>
       <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
       <FunctionLevelLinking>true</FunctionLevelLinking>

JGE/Makefile

@@ -31,8 +31,6 @@ HGE_OBJS = src/hge/hgecolor.o src/hge/hgeparticle.o \
 
 
 CXXFLAGS = -W -Wall -Werror -Wno-unused
-CXXFLAGS += -DTIXML_USE_STL
-CXXFLAGS += -Wno-deprecated-declarations -Wno-sign-compare
 
 ifdef DEBUG
 CXXFLAGS += -ggdb3
@@ -83,8 +81,8 @@ ifeq ($(TARGET_ARCHITECTURE),linux)
 OBJS = $(GENERIC_OBJS) $(LINUX_OBJS)
 TARGET_LIB = libjge.a
 TARGET_HGE = libhgetools.a
-INCDIR = $(shell freetype-config --cflags 2> /dev/null) -I/usr/X11/include -I/usr/include/boost -Isrc/zipFS -Iinclude/
+INCDIR = $(shell freetype-config --cflags 2> /dev/null) -I/usr/X11/include -I../Boost -Isrc/zipFS -Iinclude/
-CXXFLAGS += -DLINUX -DNETWORK_SUPPORT $(FMOD)
+CXXFLAGS += -DLINUX $(FMOD)
 CXXFLAGS += $(INCDIR)
 LIBDIR = lib/linux
 endif

JGE/include/DebugRoutines.h

@@ -18,9 +18,9 @@ using namespace std;
 template <class T>
 std::string ToHex(T* pointer)
 {
-	std::ostringstream stream;
+    std::ostringstream stream;
-	stream << hex << showbase << setfill('0') << setw(8) << (uint64_t) pointer;
+    stream << hex << showbase << setfill('0') << setw(8) << (uint64_t) pointer;
-	return stream.str();
+    return stream.str();
 }
 
 #ifdef LINUX
@@ -42,9 +42,9 @@ std::string ToHex(T* pointer)
 #else // CAPTURE_STDERR
 #define DebugTrace(inString)								\
 {															\
-	std::ostringstream stream;								\
+  std::ostringstream stream;								\
-	stream << inString;					    \
+  stream << inString;					    \
-	qDebug("%s", stream.str().c_str()); \
+  qDebug("%s", stream.str().c_str()); \
 }
 #endif // CAPTURE_STDERR
 
@@ -52,16 +52,16 @@ std::string ToHex(T* pointer)
 #include <android/log.h>
 #define DebugTrace(inString)								\
 {															\
-	std::ostringstream stream;								\
+  std::ostringstream stream;								\
-	stream << inString;					    \
+  stream << inString;					    \
-	__android_log_write(ANDROID_LOG_DEBUG, "Wagic", stream.str().c_str());\
+  __android_log_write(ANDROID_LOG_DEBUG, "Wagic", stream.str().c_str());\
 }
 #else
 #define DebugTrace(inString)								\
 {															\
 	std::ostringstream stream;								\
 	stream << inString << std::endl;					    \
-	OutputDebugStringA(stream.str().c_str());  \
+  OutputDebugString(stream.str().c_str());  \
 }
 #endif // QT_CONFIG
 #endif // Win32, Linux
@@ -71,7 +71,7 @@ std::string ToHex(T* pointer)
 #ifndef DebugTrace
 #define DebugTrace(inString)								\
 {															\
-	std::cerr << inString << std::endl;					    \
+  std::cerr << inString << std::endl;					    \
 }
 #endif //DEBUG
 #endif

JGE/include/Downloader.h

@@ -1,128 +0,0 @@
-#ifndef DOWNLOADER_H
-#define DOWNLOADER_H
-
-//-------------------------------------------------------------------------------------
-//
-// This class handles download of remote resources (any kind of file)
-// All the resources are stored locally in the userPath
-// For every resources, the downloader verifies if the resource was modifed
-// on the server before downloading the update. The Downloader maintains a catalogue
-// of resource downloaded to be able to check if they need to be updated.
-//
-// The interface can be used completly synchronously by the application and some
-// context or message loop is needed in the implementation of this interface
-//
-// Note that the Downloader could in theory by implemented on top of JNetwork.
-//
-//-------------------------------------------------------------------------------------
-#include <string>
-#include <ostream>
-#include <istream>
-#include <fstream>
-#include <map>
-#include "Threading.h"
-#ifdef QT_CONFIG
-#include <QObject>
-#include <QNetworkRequest>
-#include <QNetworkReply>
-#include <QNetworkAccessManager>
-#endif
-
-using namespace std;
-
-class DownloadRequest
-        #ifdef QT_CONFIG
-        : public QObject
-        #endif
-{
-#ifdef QT_CONFIG
-    Q_OBJECT
-
-private slots:
-#endif
-    void fileDownloaded();
-    void downloadProgress(qint64 bytesReceived, qint64 bytesTotal);
-
-#ifdef QT_CONFIG
-signals:
-    void percentChanged(int percent);
-    void statusChanged(int);
-#endif
-
-public:
-    typedef enum {
-        NOT_PRESENT,
-        DOWNLOADING,
-        DOWNLOADED,
-        DOWNLOAD_ERROR
-    } DownloadStatus;
-
-protected:
-    string mLocalPath;
-    string mRemoteResourceURL;
-    // previous one is the original, next one can change after redirection
-    string mRequestedRemoteResourceURL;
-    string mETag;
-    DownloadStatus mDownloadStatus;
-    bool mUpgradeAvailable;
-    size_t mTotalSize;
-    size_t mCurrentSize;
-    ofstream mFile;
-#ifdef QT_CONFIG
-    QNetworkReply* mNetworkReply;
-    static QNetworkAccessManager networkAccessManager;
-#endif
-
-
-public:
-    DownloadRequest(string localPath="",
-                    string remoteResourceURL="",
-                    string ETag = "",
-                    DownloadStatus downloadStatus=NOT_PRESENT,
-                    size_t totalSize = 0,
-                    size_t currentSize = 0);
-    ~DownloadRequest();
-    static bool NetworkIsAccessible();
-
-    string getTempLocalPath() const { return (mLocalPath+".tmp"); };
-    string getLocalPath() const { return mLocalPath; };
-    string getRemoteResource() const { return mRemoteResourceURL; };
-    string getETag() const { return mETag; };
-    void startGet();
-    void startHead();
-    DownloadStatus getDownloadStatus() const { return mDownloadStatus; };
-    bool upgradeAvailable() const { return mUpgradeAvailable; };
-    void getSizes(size_t& totalSize, size_t&currentSize) {
-        totalSize = mTotalSize;
-        currentSize = mCurrentSize;
-    };
-
-    friend ostream& operator<<(ostream& out, const DownloadRequest& d);
-    friend istream& operator>>(istream&, DownloadRequest&);
-    friend class Downloader;
-};
-
-
-class Downloader
-{
-protected:
-    Downloader(string globalRemoteURL="", string localCacheRecords="");
-    virtual ~Downloader();
-    static Downloader* mInstance;
-    string mGlobalRemoteURL;
-    string mLocalCacheRecords;
-    boost::mutex mMutex;
-    map<string, DownloadRequest*> mRequestMap;
-
-public:
-    static Downloader* GetInstance();
-    static void Release();
-
-    void Update();
-    DownloadRequest* Get(string localPath, string remoteResourceURL="");
-
-    friend ostream& operator<<(ostream& out, const Downloader& d);
-    friend istream& operator>>(istream&, Downloader&);
-};
-
-#endif // DOWNLOADER_H

JGE/include/JAnimator.h

@@ -297,6 +297,7 @@ public:
 private:
 	float mTimer;
 	float mFrameTime;
+	JAnimator* mAnimator;
 	vector<JAnimatorObject *> mObjects;
 
 };

JGE/include/JDistortionMesh.h

@@ -37,6 +37,7 @@ private:
 	float mTexY;
 	float mTexWidth;
 	float mTexHeight;
+	JTexture* mTexture;
 	JQuad* mQuad;
 	
 	

JGE/include/JFileSystem.h

@@ -128,7 +128,6 @@ public:
     bool readIntoString(const string & FilePath, string & target);
     bool openForWrite(ofstream & File, const string & FilePath, ios_base::openmode mode = ios_base::out );
     bool Rename(string from, string to);
-    bool Remove(string aFile);
 
     //Returns true if strFilename exists somewhere in the fileSystem
     bool FileExists(const string& strFilename);
@@ -164,4 +163,4 @@ protected:
 
 
 
-#endif
+#endif

JGE/include/JGE.h

@@ -394,7 +394,6 @@ class JGE
    void SetJNIEnv(JNIEnv * env, jclass cls);
    void sendJNICommand(std::string command);
    std::string getFileSystemLocation();
-   std::string getFileUserFolderPath();
 #endif 
   
  protected:

JGE/include/JGui.h

@@ -30,7 +30,6 @@ const int kInfoMenuID = -200;
 const int kRandomPlayerMenuID = -11;
 const int kRandomAIPlayerMenuID = -12;
 const int kEvilTwinMenuID = -14;
-const int kCommanderMenuID = -33;
 
 class JGuiListener
 {

JGE/include/JLBFont.h

@@ -178,6 +178,8 @@ private:
 	float       mSpacing;
 
 	PIXEL_TYPE		mColor;
+	int			mBlend;
+
 	int			mBase;
 
 };

JGE/include/JRenderer.h

@@ -598,6 +598,8 @@ private:
   GLint     prog2_positionLoc;
   GLint     prog2_texCoordLoc;
   GLint     prog2_colorLoc;
+  // MVP matrix
+  ESMatrix  prog2_mvpMatrix;
   // Uniform locations
   GLint     prog2_mvpLoc;
 
@@ -610,11 +612,13 @@ private:
   int mCurrentTextureFormat;
 #endif
 
-#ifdef PSP
 	bool mVsync;
-    int mTexCounter;
+
-#endif
 	int mSwizzle;
+	int mTexCounter;
+  
+
+
 	int mCurrentTextureFilter;
 
 	int mCurrTexBlendSrc;

JGE/include/JSoundSystem.h

@@ -23,32 +23,28 @@
 #include "SLES/OpenSLES_Android.h"
 
 #elif defined USE_PHONON
-#include <phonon/AudioOutput>
+    #include <phonon/AudioOutput>
-#include <phonon/MediaObject>
+    #include <phonon/MediaObject>
-#elif (defined QT_CONFIG)
-#include "QMediaPlayer"
-#include "QMediaPlaylist"
-#include "QSoundEffect"
 #elif defined WIN32
-#include <windows.h>
+    #include <windows.h>
 #define WITH_FMOD
 #elif defined (PSP)
-#include <pspgu.h>
+    #include <pspgu.h>
-#include <pspkernel.h>
+    #include <pspkernel.h>
-#include <pspdisplay.h>
+    #include <pspdisplay.h>
-#include <pspdebug.h>
+    #include <pspdebug.h>
-#include <pspctrl.h>
+    #include <pspctrl.h>
-#include <time.h>
+    #include <time.h>
-#include <string.h>
+    #include <string.h>
-#include <pspaudiolib.h>
+    #include <pspaudiolib.h>
-#include <psprtc.h>
+    #include <psprtc.h>
 
-#include "JAudio.h"
+    #include "JAudio.h"
-#include "JMP3.h"
+    #include "JMP3.h"
 #endif
 
 #ifdef WITH_FMOD
-#include "../Dependencies/include/fmod.h"
+    #include "../Dependencies/include/fmod.h"
 #endif
 
 //------------------------------------------------------------------------------------------------
@@ -71,7 +67,7 @@ public:
 #ifdef USE_PHONON
     Phonon::AudioOutput* mOutput;
     Phonon::MediaObject* mMediaObject;
-public slots:
+    public slots:
     void seekAtTheBegining();
 #elif defined (PSP)
     JMP3* mTrack;
@@ -86,10 +82,6 @@ public slots:
     SLPlayItf playInterface;
     SLSeekItf seekInterface;
     SLVolumeItf musicVolumeInterface;
-#elif (defined QT_CONFIG)
-    QMediaPlaylist* playlist;
-    QMediaPlayer* player;
-    string fullpath;
 #else
     void* mTrack;
 #endif  //WITH_FMOD
@@ -100,15 +92,13 @@ public slots:
 //------------------------------------------------------------------------------------------------    
 class JSample
 {
-public:
+ public:
     JSample();
     ~JSample();
 
     unsigned long fileSize();
-#if (defined QT_CONFIG) && (!defined USE_PHONON)
+
-    QMediaPlayer* effect;
+#if defined (PSP)
-    void* mSample;
-#elif defined (PSP)
     WAVDATA *mSample;
 #elif defined (IOS)
     std::string filename;
@@ -143,130 +133,126 @@ class JSoundSystem
 
 public:
 
-    //////////////////////////////////////////////////////////////////////////
+	//////////////////////////////////////////////////////////////////////////
-    /// Get the singleton instance
+	/// Get the singleton instance
-    ///
+	///
-    //////////////////////////////////////////////////////////////////////////
+	//////////////////////////////////////////////////////////////////////////
-    static JSoundSystem* GetInstance();
+	static JSoundSystem* GetInstance();
 
-    static void Destroy();
+	static void Destroy();
 
 
 
-    //////////////////////////////////////////////////////////////////////////
+	//////////////////////////////////////////////////////////////////////////
-    /// Load music.
+	/// Load music.
-    ///
+	///
-    /// @note MP3 is the only supported format for the moment.
+	/// @note MP3 is the only supported format for the moment.
-    ///
+	///
-    /// @param filename - Name of the music file.
+	/// @param filename - Name of the music file.
-    ///
+	///
-    //////////////////////////////////////////////////////////////////////////
+	//////////////////////////////////////////////////////////////////////////
-    JMusic *LoadMusic(const char *fileName);
+	JMusic *LoadMusic(const char *fileName);
 
-    //////////////////////////////////////////////////////////////////////////
+	//////////////////////////////////////////////////////////////////////////
-    /// Delete music from memory.
+	/// Delete music from memory.
-    ///
+	///
-    /// @param music - Music to be deleted.
+	/// @param music - Music to be deleted.
-    ///
+	///
-    //////////////////////////////////////////////////////////////////////////
+	//////////////////////////////////////////////////////////////////////////
-    //void FreeMusic(JMusic *music);
+	//void FreeMusic(JMusic *music);
 
-    //////////////////////////////////////////////////////////////////////////
+	//////////////////////////////////////////////////////////////////////////
-    /// Play music.
+	/// Play music.
-    ///
+	///
-    /// @param music - Music to be played.
+	/// @param music - Music to be played.
-    /// @param looping - Play the music in a loop.
+	/// @param looping - Play the music in a loop.
-    ///
+	///
-    //////////////////////////////////////////////////////////////////////////
+	//////////////////////////////////////////////////////////////////////////
-    void PlayMusic(JMusic *music, bool looping = false);
+	void PlayMusic(JMusic *music, bool looping = false);
 
-    //////////////////////////////////////////////////////////////////////////
+	//////////////////////////////////////////////////////////////////////////
-    /// Stop playing.
+	/// Stop playing.
-    ///
+	///
-    /// @param music - Music to be stopped.
+	/// @param music - Music to be stopped.
-    ///
+	///
-    //////////////////////////////////////////////////////////////////////////
+	//////////////////////////////////////////////////////////////////////////
-    void StopMusic(JMusic *music);
+	void StopMusic(JMusic *music);
 
     
-    //////////////////////////////////////////////////////////////////////////
+	//////////////////////////////////////////////////////////////////////////
-    /// Resume playing.
+	/// Resume playing.
-    ///
+	///
-    /// @param music - Music to be resumed.
+	/// @param music - Music to be resumed.
-    ///
+	///
-    //////////////////////////////////////////////////////////////////////////
+	//////////////////////////////////////////////////////////////////////////
-    void ResumeMusic(JMusic *music);
+	void ResumeMusic(JMusic *music);
     
-    //////////////////////////////////////////////////////////////////////////
+	//////////////////////////////////////////////////////////////////////////
-    /// Pause playing.
+	/// Pause playing.
-    ///
+	///
-    /// @param music - Music to be paused.
+	/// @param music - Music to be paused.
-    ///
+	///
-    //////////////////////////////////////////////////////////////////////////
+	//////////////////////////////////////////////////////////////////////////
-    void PauseMusic(JMusic *music);
+	void PauseMusic(JMusic *music);
 
-    //////////////////////////////////////////////////////////////////////////
+	//////////////////////////////////////////////////////////////////////////
-    /// Load sound effect.
+	/// Load sound effect.
-    ///
+	///
-    /// @note WAV sound effect only.
+	/// @note WAV sound effect only.
-    ///
+	///
-    /// @param fileName - Sound effect for loading.
+	/// @param fileName - Sound effect for loading.
-    ///
+	///
-    //////////////////////////////////////////////////////////////////////////
+	//////////////////////////////////////////////////////////////////////////
-    JSample *LoadSample(const char *fileName);
+	JSample *LoadSample(const char *fileName);
 
-    //////////////////////////////////////////////////////////////////////////
+	//////////////////////////////////////////////////////////////////////////
-    /// Delete sound effect from memory.
+	/// Delete sound effect from memory.
-    ///
+	///
-    /// @param sample - Sound to be deleted.
+	/// @param sample - Sound to be deleted.
-    ///
+	///
-    //////////////////////////////////////////////////////////////////////////
+	//////////////////////////////////////////////////////////////////////////
-    //void FreeSample(JSample *sample);
+	//void FreeSample(JSample *sample);
 
-    //////////////////////////////////////////////////////////////////////////
+	//////////////////////////////////////////////////////////////////////////
-    /// Play sound effect.
+	/// Play sound effect.
-    ///
+	///
-    /// @param sample - Sound for playing.
+	/// @param sample - Sound for playing.
-    ///
+	///
-    //////////////////////////////////////////////////////////////////////////
+	//////////////////////////////////////////////////////////////////////////
-    void PlaySample(JSample *sample);
+	void PlaySample(JSample *sample);
 
-    //////////////////////////////////////////////////////////////////////////
+	//////////////////////////////////////////////////////////////////////////
-    /// Set volume for audio playback.
+	/// Set volume for audio playback.
-    ///
+	///
-    /// @param volume - New volume.
+	/// @param volume - New volume.
-    ///
+	///
-    //////////////////////////////////////////////////////////////////////////
+	//////////////////////////////////////////////////////////////////////////
-    void SetVolume(int volume);
+  void SetVolume(int volume);
 
-    void SetMusicVolume(int volume);
+	void SetMusicVolume(int volume);
 
-    void SetSfxVolume(int volume);
+  void SetSfxVolume(int volume);
 
-    int mChannel;
+  	int mChannel;
 protected:
-    JSoundSystem();
+	JSoundSystem();
-    ~JSoundSystem();
+	~JSoundSystem();
 
-    void InitSoundSystem();
+	void InitSoundSystem();
-    void DestroySoundSystem();
+	void DestroySoundSystem();
 
 private:
-#if (defined PSP || defined ANDROID)
+
-    JMusic *mCurrentMusic;
+	JMusic *mCurrentMusic;
     JSample *mCurrentSample;
-#endif
 
-    int mVolume;
+	int mVolume;
-#ifndef IOS
+  int mMusicVolume;
-    int mMusicVolume;
+  int mSampleVolume;
-#endif
-    int mSampleVolume;
 
 
-    static JSoundSystem* mInstance;
+	static JSoundSystem* mInstance;
 
 };
 
 #endif
-

JGE/include/JSpline.h

@@ -18,11 +18,12 @@ using namespace std;
 
 #define MID_POINT_THRESHOLD			1.0f
 
+
 //////////////////////////////////////////////////////////////////////////
 /// Position of a single dot on screen.
 /// 
 //////////////////////////////////////////////////////////////////////////
-class JPoint
+class Point
 {
 public:
 
@@ -33,13 +34,13 @@ public:
 	/// @param _y - Y position.
 	/// 
 	//////////////////////////////////////////////////////////////////////////
-    JPoint(float _x, float _y) { x = _x; y = _y; }
+	Point(float _x, float _y) { x = _x; y = _y; }
 
 	//////////////////////////////////////////////////////////////////////////
 	/// Constructor, set position to default (0.0f, 0.0f)
 	/// 
 	//////////////////////////////////////////////////////////////////////////
-    JPoint() { x = 0.0f; y = 0.0f; }
+	Point() { x = 0.0f; y = 0.0f; }
 
 	float x;	///< X position.
 	float y;	///< Y position.
@@ -94,7 +95,7 @@ public:
 	/// @param pt - Control point.
 	/// 
 	//////////////////////////////////////////////////////////////////////////
-    void AddControlPoint(const JPoint &pt);
+	void AddControlPoint(const Point &pt);
 
 	//////////////////////////////////////////////////////////////////////////
 	/// Get a control point of the spline.
@@ -104,7 +105,7 @@ public:
 	/// @return Control point.
 	/// 
 	//////////////////////////////////////////////////////////////////////////
-    void GetControlPoint(JPoint &point, int index);
+	void GetControlPoint(Point &point, int index);
 
 	//////////////////////////////////////////////////////////////////////////
 	/// Work out all pixels of the spline.
@@ -127,7 +128,7 @@ public:
 	/// @return Position of the desire point.
 	/// 
 	//////////////////////////////////////////////////////////////////////////
-    void PointOnCurve(JPoint &out, float t, const JPoint &p0, const JPoint &p1, const JPoint &p2, const JPoint &p3);
+	void PointOnCurve(Point &out, float t, const Point &p0, const Point &p1, const Point &p2, const Point &p3);
 
 	//////////////////////////////////////////////////////////////////////////
 	/// Get a number of pixels for this spline.
@@ -145,7 +146,7 @@ public:
 	/// @return Position of the desire point.
 	/// 
 	//////////////////////////////////////////////////////////////////////////
-    void GetPixel(JPoint &point, int index);
+	void GetPixel(Point &point, int index);
 
 	//////////////////////////////////////////////////////////////////////////
 	/// Render the spline to screen.
@@ -155,8 +156,8 @@ public:
 
 private:
 
-    vector<JPoint> mMidPoints;
+	vector<Point> mMidPoints;
-    vector<JPoint> mPixels;
+	vector<Point> mPixels;
 	int mCount;
 
 };

JGE/include/Threading.h

@@ -1,7 +1,7 @@
 #ifndef THREADING_H
 #define THREADING_H
 
-#if !defined(PSP) && !defined(QT_CONFIG) && !(__cplusplus > 199711L)
+#if !defined(PSP) && !defined(QT_CONFIG)
 #include <boost/date_time.hpp>
 
 #ifdef WIN32
@@ -14,7 +14,7 @@
 #endif
 
 #include <boost/thread/mutex.hpp>
-#elif defined(PSP)
+#elif !defined(QT_CONFIG)
 #include <boost/bind.hpp>
 #include <boost/shared_ptr.hpp>
 
@@ -26,7 +26,7 @@
 namespace boost
 {
     /**
-    ** PSP specific variant of a boost mutex & scoped_lock
+    ** PSP specific variant of a boost mutex & scoped_lock 
     */
 
     template <class Mutex>
@@ -60,7 +60,7 @@ namespace boost
         {
             sceKernelDeleteSema(mID);
         }
-
+        
         void lock()
         {
             int result = sceKernelWaitSema(mID, 1, 0);
@@ -142,7 +142,7 @@ namespace boost
             }
 
         }
-
+        
         int mID;
         int mThreadID;
         volatile int mRecursionCount;
@@ -164,7 +164,7 @@ namespace boost
 
 
     /**
-    ** Emulating boost::thread configuration glue, with some shortcuts
+    ** Emulating boost::thread configuration glue, with some shortcuts 
     ** This detail namespace is a distillation of boost's thread.hpp, thread_data.hpp.
     */
     namespace detail
@@ -212,13 +212,13 @@ namespace boost
     **
     ** The intent of its usage is this form only:
     ** mWorkerThread = boost::thread(ThreadProc, this);
-    ** where ThreadProc is a static member function of the 'this' class,eg:
+	** where ThreadProc is a static member function of the 'this' class,eg:
-    ** static void FOO::ThreadProc(void* inParam)
+	** static void FOO::ThreadProc(void* inParam)
-    ** {
+	** {
-    **		FOO* instance = reinterpret_cast<FOO*>(inParam);
+	**		FOO* instance = reinterpret_cast<FOO*>(inParam);
-    **		// now you have class instance data available...
+	**		// now you have class instance data available...
-    ** }
+	** }
-    **
+	** 
     ** Any other variant of a thread proc with more than one param is unimplemented.
     */
     class thread
@@ -227,7 +227,7 @@ namespace boost
         ** Helper class for sceKernelStartThread, which passes args by value, not by reference
         ** We use this struct to wrap any pointers that we want to pass to the worker thread.
         */
-        struct CallbackData
+        struct CallbackData 
         {
             CallbackData(detail::thread_data_ptr inThreadInfo)
                 : mThreadInfo(inThreadInfo)
@@ -307,11 +307,13 @@ namespace boost
     }
 }
 
-#elif defined(QT_CONFIG) && (__cplusplus <= 199711L)
+#elif defined(QT_CONFIG)
 
 #include <QMutex>
 #include <QThread>
-#include <QSharedPointer>
+
+#include <boost/bind.hpp>
+#include <boost/shared_ptr.hpp>
 
 #include "../include/JLogger.h"
 
@@ -418,25 +420,23 @@ namespace boost
             virtual void run() = 0;
         };
 
+        typedef boost::shared_ptr<detail::thread_data_base> thread_data_ptr;
 
-        typedef QSharedPointer<detail::thread_data_base> thread_data_ptr;
+        template<typename F>
-
-        template<typename F, typename A1>
         class thread_data : public detail::thread_data_base
         {
         public:
-            thread_data(F f_, A1 a1_) : f(f_), a1(a1_)
+            thread_data(F f_) : f(f_)
             {
             }
 
             void run()
             {
-                f(a1);
+                f();
             }
 
         private:
             F f;
-            A1 a1;
 
             void operator=(thread_data&);
             thread_data(thread_data&);
@@ -493,7 +493,7 @@ namespace boost
         }
 
         template <class F,class A1>
-        thread(F f, A1 a1) : mThreadInfo(make_thread_info(f, a1))
+        thread(F f, A1 a1) : mThreadInfo(make_thread_info(boost::bind(boost::type<void>(), f, a1)))
         {
             mpThread = new threadImpl(mThreadInfo);
             LOG("Calling start func");
@@ -510,10 +510,10 @@ namespace boost
         }
 
     private:
-        template<typename F, typename A1>
+        template<typename F>
-        static inline detail::thread_data_ptr make_thread_info(F f, A1 a1)
+        static inline detail::thread_data_ptr make_thread_info(F f)
         {
-            return detail::thread_data_ptr(new detail::thread_data<F, A1>(f, a1));
+            return detail::thread_data_ptr(new detail::thread_data<F>(f));
         }
 
         detail::thread_data_ptr mThreadInfo;
@@ -537,80 +537,6 @@ namespace boost
     }
 }
 
-#elif (__cplusplus > 199711L)
-
-#include <thread>
-#include <mutex>
-
-namespace boost
-{
-    typedef std::thread thread;
-
-    template <class Mutex>
-    struct unique_lock
-    {
-        unique_lock(Mutex& inMutex) : mMutex(&inMutex)
-        {
-            mMutex->lock();
-        }
-
-        ~unique_lock()
-        {
-            mMutex->unlock();
-        }
-
-        Mutex* mMutex;
-    };
-
-    class mutex
-    {
-    public:
-
-        typedef unique_lock<mutex> scoped_lock;
-
-        mutex()
-          : mQMutex()
-        {
-        }
-
-        ~mutex()
-        {
-        }
-
-        void lock()
-        {
-            mQMutex.lock();
-        }
-
-        void unlock()
-        {
-            mQMutex.unlock();
-        }
-
-        std::mutex mQMutex;
-
-    private:
-        mutex(mutex const&);
-        mutex& operator=(mutex const&);
-    };
-
-    namespace posix_time
-    {
-        typedef unsigned int milliseconds;
-    }
-
-    /**
-    ** boost's platform neutral sleep call.
-    */
-    namespace this_thread
-    {
-        inline void sleep(boost::posix_time::milliseconds const& time)
-        {
-            std::this_thread::sleep_for(std::chrono::milliseconds(time));
-        }
-    }
-}
-
 #endif
 
 #endif // THREADING_H

JGE/include/qt/corewrapper.h

@@ -136,20 +136,6 @@ signals:
 private slots:
 
 private:
-    int lastPosx(){
-#if QT_VERSION >= 0x050100
-        return m_lastPos.x()*devicePixelRatio();
-#else
-        return m_lastPos.x();
-#endif
-    }
-    int lastPosy(){
-#if QT_VERSION >= 0x050100
-        return m_lastPos.y()*devicePixelRatio();
-#else
-        return m_lastPos.y();
-#endif
-    }
     void timerEvent( QTimerEvent* );
     void doAndEnqueue(JButton action) {
         m_engine->HoldKey_NoRepeat(action);
@@ -168,7 +154,6 @@ private:
     int m_timerId;
     bool m_active;
     QRect m_viewPort;
-    QPoint m_lastPos;
 #ifdef QT_WIDGET
 #if (defined Q_WS_MAEMO_5) || (defined MEEGO_EDITION_HARMATTAN) || (defined Q_WS_ANDROID)
   int mMouseDownX;

JGE/src/Downloader.cpp

@@ -1,298 +0,0 @@
-#include "DebugRoutines.h"
-#include "JFileSystem.h"
-#include "Downloader.h"
-
-#define RECORDS_DEFAULT_FILE "cache/records.txt"
-
-#ifdef QT_CONFIG
-QNetworkAccessManager DownloadRequest::networkAccessManager;
-#endif
-
-DownloadRequest::DownloadRequest(string localPath,
-                    string remoteResourceURL,
-                    string ETag,
-                    DownloadStatus downloadStatus,
-                    size_t totalSize,
-                    size_t currentSize):
-    mLocalPath(localPath),
-    mRemoteResourceURL(remoteResourceURL),
-    mRequestedRemoteResourceURL(remoteResourceURL),
-    mETag(ETag),
-    mDownloadStatus(downloadStatus),
-    mUpgradeAvailable(false),
-    mTotalSize(totalSize),
-    mCurrentSize(currentSize)
-{
-}
-
-DownloadRequest::~DownloadRequest()
-{
-}
-
-void DownloadRequest::startHead()
-{
-#ifdef QT_CONFIG
-    QNetworkRequest request(QUrl(QString(mRequestedRemoteResourceURL.c_str())));
-    request.setRawHeader("If-None-Match", mETag.c_str());
-    mNetworkReply = networkAccessManager.head(request);
-    connect(mNetworkReply, SIGNAL(finished()), SLOT(fileDownloaded()));
-#endif
-}
-
-void DownloadRequest::startGet()
-{
-#ifdef QT_CONFIG
-    mNetworkReply = networkAccessManager.get(QNetworkRequest(QUrl(QString(mRequestedRemoteResourceURL.c_str()))));
-#endif
-    mFile.close();
-    JFileSystem::GetInstance()->Remove(getTempLocalPath());
-    JFileSystem::GetInstance()->openForWrite(mFile, getTempLocalPath());
-#ifdef QT_CONFIG
-    connect(mNetworkReply, SIGNAL(downloadProgress(qint64, qint64)),
-                SLOT(downloadProgress(qint64, qint64)));
-    connect(mNetworkReply, SIGNAL(finished()), SLOT(fileDownloaded()));
-#endif
-}
-
-void DownloadRequest::fileDownloaded()
-{
-    do {
-        QByteArray eTagByteArray = mNetworkReply->rawHeader("ETag");
-        if(!eTagByteArray.isEmpty()) {
-            string oldETag = mETag;
-            mETag = QString(eTagByteArray).toStdString();
-            if(oldETag!="" && oldETag != mETag)
-                mUpgradeAvailable = true;
-        }
-
-        // let's check some error
-        if(mNetworkReply->error() != QNetworkReply::NoError) {
-            DebugTrace(mNetworkReply->errorString().toStdString());
-            mDownloadStatus = DownloadRequest::DOWNLOAD_ERROR;
-            mFile.close();
-            JFileSystem::GetInstance()->Remove(getTempLocalPath());
-            break;
-        }
-
-        // check if we're getting redirected
-        QVariant redirectionTarget = mNetworkReply->attribute(QNetworkRequest::RedirectionTargetAttribute);
-        if (!redirectionTarget.isNull()) {
-            QUrl newUrl = QUrl(mRequestedRemoteResourceURL.c_str()).resolved(redirectionTarget.toUrl());
-            DebugTrace(string("Redirect to ")+ newUrl.toString().toStdString());
-
-            mRequestedRemoteResourceURL = newUrl.toString().toStdString();
-            mNetworkReply->deleteLater();
-            if(mFile.is_open())
-                startGet();
-            else
-                startHead();
-            return;
-        }
-
-        if(mFile.is_open())
-        {
-            QByteArray byteArray = mNetworkReply->readAll();
-            mFile.write(byteArray.constData(), byteArray.size());
-            mFile.close();
-            if(!JFileSystem::GetInstance()->Rename(getTempLocalPath(), mLocalPath)) {
-                mDownloadStatus = DownloadRequest::DOWNLOAD_ERROR;
-                break;
-            }
-        }
-        mDownloadStatus = DownloadRequest::DOWNLOADED;
-    } while(0);
-
-    Downloader::GetInstance()->Update();
-    mNetworkReply->deleteLater();
-
-    emit statusChanged((int)mDownloadStatus);
-}
-
-void DownloadRequest::downloadProgress(qint64 bytesReceived, qint64 bytesTotal)
-{
-    QByteArray byteArray = mNetworkReply->readAll();
-    mFile.write(byteArray.constData(), byteArray.size());
-    mCurrentSize = bytesReceived;
-    mTotalSize = bytesTotal;
-    int percent = 0;
-    if(bytesTotal)
-        percent = (bytesReceived/bytesTotal)*100;
-    emit percentChanged(percent);
-}
-
-Downloader* Downloader::mInstance = 0;
-
-Downloader::Downloader(string globalRemoteURL, string localcacheRecords):
-    mGlobalRemoteURL(globalRemoteURL),
-    mLocalCacheRecords(localcacheRecords)
-{
-    JFileSystem::GetInstance()->MakeDir("cache");
-
-    izfstream downloadRecords;
-    if(mLocalCacheRecords.empty())
-        mLocalCacheRecords = RECORDS_DEFAULT_FILE;
-    if(JFileSystem::GetInstance()->openForRead(downloadRecords, mLocalCacheRecords))
-    {// File exists, let's read it.
-        downloadRecords >> (*this);
-    }
-    JFileSystem::GetInstance()->CloseFile();
-}
-
-Downloader::~Downloader()
-{
-    map<string, DownloadRequest*>::iterator ite;
-    for(ite = mRequestMap.begin(); ite != mRequestMap.end(); ite++)
-    {
-        delete (*ite).second;
-    }
-    mRequestMap.erase(mRequestMap.begin(), mRequestMap.end());
-}
-
-Downloader* Downloader::GetInstance()
-{
-    if(!mInstance)
-    {
-        mInstance = new Downloader();
-    }
-    return mInstance;
-}
-
-void Downloader::Release()
-{
-    if(mInstance)
-    {
-        delete mInstance;
-        mInstance = 0;
-    }
-}
-
-bool DownloadRequest::NetworkIsAccessible()
-{
-    bool result = false;
-
-#ifdef QT_CONFIG
-    networkAccessManager.setNetworkAccessible(QNetworkAccessManager::Accessible);
-    result = networkAccessManager.networkAccessible();
-#endif
-
-    return result;
-}
-
-DownloadRequest* Downloader::Get(string localPath, string remoteResourceURL)
-{
-    map<string, DownloadRequest*>::iterator ite = mRequestMap.find(localPath);
-    if(ite == mRequestMap.end())
-    { // request does not exist, let's create it
-        DownloadRequest* request = new DownloadRequest(localPath, remoteResourceURL);
-        std::pair<std::map<string,DownloadRequest*>::iterator,bool> ret;
-        ret = mRequestMap.insert ( std::pair<string,DownloadRequest*>(localPath, request) );
-        if (ret.second==false) {
-            DebugTrace("Downloader::Get Error inserting request in Map");
-            return 0;
-        }
-        ite = ret.first;
-    }
-
-    // Now, we can check the server
-    if((*ite).second->getDownloadStatus() == DownloadRequest::NOT_PRESENT ||
-            (*ite).second->upgradeAvailable())
-    {   // File is not here or an update is available, let's get it
-        (*ite).second->startGet();
-        (*ite).second->mDownloadStatus = DownloadRequest::DOWNLOADING;
-    }
-    else if ((*ite).second->getDownloadStatus() == DownloadRequest::DOWNLOADED)
-    {   // File is here, let's check if there is some update without blocking the playback
-        (*ite).second->startHead();
-    }
-
-    return (*ite).second;
-}
-
-void Downloader::Update()
-{
-    ofstream downloadRecords;
-    if(JFileSystem::GetInstance()->openForWrite(downloadRecords, mLocalCacheRecords))
-    {
-        downloadRecords << (*this);
-    }
-    downloadRecords.close();
-}
-
-ostream& operator<<(ostream& out, const DownloadRequest& d)
-{
-//    HEAD request fails, so this line erase cache record after upgrade check :(
-//    if(d.getDownloadStatus() == DownloadRequest::DOWNLOADED)
-    {
-        out << "localPath=" << d.mLocalPath << endl;
-        out << "remoteResource=" << d.mRemoteResourceURL << endl;
-        out << "ETag=" << d.mETag << endl;
-        out << "upgradeAvailable=" << d.mUpgradeAvailable <<endl;
-    }
-
-    return out;
-}
-
-istream& operator>>(istream& in, DownloadRequest& d)
-{
-    string s;
-
-    while(std::getline(in, s))
-    {
-        size_t limiter = s.find("=");
-        string areaS;
-        if (limiter != string::npos)
-        {
-            areaS = s.substr(0, limiter);
-            if (areaS.compare("localPath") == 0)
-            {
-                d.mLocalPath = s.substr(limiter + 1);
-            }
-            else if (areaS.compare("remoteResource") == 0)
-            {
-                d.mRemoteResourceURL = s.substr(limiter + 1);
-                d.mRequestedRemoteResourceURL = d.mRemoteResourceURL;
-            }
-            else if (areaS.compare("ETag") == 0)
-            {
-                d.mETag = s.substr(limiter + 1);
-                d.mDownloadStatus = DownloadRequest::DOWNLOADED;
-            }
-            else if (areaS.compare("upgradeAvailable") == 0)
-            {
-                d.mUpgradeAvailable = (bool)atoi(s.substr(limiter + 1).c_str());
-                break;
-            }
-        }
-    }
-
-    return in;
-}
-
-ostream& operator<<(ostream& out, const Downloader& d)
-{
-    map<string, DownloadRequest*>::const_iterator ite;
-    for(ite = d.mRequestMap.begin(); ite != d.mRequestMap.end(); ite++)
-    {
-        out << (*(*ite).second) << endl;
-    }
-    return out;
-}
-
-istream& operator>>(istream& in, Downloader& d)
-{
-    while(!in.eof())
-    {
-        DownloadRequest* downloadRequest = new DownloadRequest();
-        in >> (*downloadRequest);
-
-        if(!downloadRequest->getLocalPath().empty() &&
-           !downloadRequest->getRemoteResource().empty() &&
-           !downloadRequest->getETag().empty()) {
-            d.mRequestMap[downloadRequest->getLocalPath()] = downloadRequest;
-        } else {
-            delete downloadRequest;
-        }
-    }
-    return in;
-}
-

JGE/src/JAnimator.cpp

@@ -67,7 +67,7 @@ bool JAnimator::Load(const char* scriptFile)
 		element = script->ToElement();
 		printf("---- Loading %s:%s\n", element->Value(), element->Attribute("name"));
 
-		string type[] =
+		const char *type[] =
 		{
 			"ANIMATION_TYPE_LOOPING",
 			"ANIMATION_TYPE_ONCE_AND_STAY",
@@ -78,7 +78,7 @@ bool JAnimator::Load(const char* scriptFile)
 
 		const char* aniType = element->Attribute("type");
 		for (int i=0;i<5;i++)
-			if (type[i] == aniType)
+			if (strcmp(type[i], aniType)==0)
 			{
 				SetAnimationType(i);
 				break;
@@ -108,7 +108,7 @@ bool JAnimator::Load(const char* scriptFile)
 					element = param->ToElement();
 					if (element != NULL)
 					{
-						if (element->ValueStr() == "settings")
+						if (strcmp(element->Value(), "settings")==0)
 						{
 							const char* quadName = element->Attribute("quad");
 							JQuad* quad = mResource->GetQuad(quadName);

JGE/src/JFileSystem.cpp

@@ -16,14 +16,9 @@ User folder is the only one that is really needed to guarantee both read and wri
 The content that users should not be touching.
 */
 
-#if defined (ANDROID)
+#ifndef PSP
 #include "PrecompiledHeader.h"
-#endif //ANDROID
+#endif //PSP
-
-#if defined (LINUX)
-#include "../../projects/mtg/include/PrecompiledHeader.h"
-#endif //LINUX
-
 
 #ifdef WIN32
 #pragma warning(disable : 4786)
@@ -43,12 +38,6 @@ The content that users should not be touching.
 #include <QDir>
 #endif
 
-/*
-#ifdef IOS
-#include <Foundation/Foundation.h>
-#endif
-*/
-
 JFileSystem* JFileSystem::mInstance = NULL;
 
 JZipCache::JZipCache()
@@ -131,14 +120,13 @@ JFileSystem::JFileSystem(const string & _userPath, const string & _systemPath)
     systemPath = [[documentsDirectory  stringByAppendingString: @"/Res/"] cStringUsingEncoding:1];
 
 #elif defined (ANDROID)
-    userPath = JGE::GetInstance()->getFileUserFolderPath();
+    userPath = JGE::GetInstance()->getFileSystemLocation();
-    systemPath = JGE::GetInstance()->getFileSystemLocation();
+    systemPath = "";
 
-    DebugTrace("User path " << userPath);
+	DebugTrace("User path " << userPath);
-    DebugTrace("System path " << systemPath);
 #elif defined (QT_CONFIG)
 
-    QDir sysDir(RESDIR);
+    QDir sysDir("projects/mtg/bin/Res");
     QDir dir(QDir::homePath());
     dir.mkdir(USERDIR);
     dir.cd(USERDIR);
@@ -260,15 +248,14 @@ void JFileSystem::clearZipCache()
 
 bool JFileSystem::AttachZipFile(const string &zipfile, char *password /* = NULL */)
 {
-#ifndef WIN32
+    if (mZipAvailable && mZipFile != NULL)
-    if (mZipAvailable && mZipFile.is_open())
     {
         if (mZipFileName != zipfile)
             DetachZipFile();		// close the previous zip file
         else
             return true;
     }
-#endif
+
     mZipFileName = zipfile;
     mPassword = password;
 
@@ -326,15 +313,11 @@ bool JFileSystem::readIntoString(const string & FilePath, string & target)
 
     int fileSize = GetFileSize(file);
 
-#ifndef __MINGW32__
     try {
-#endif
         target.resize((std::string::size_type) fileSize);
-#ifndef __MINGW32__
     } catch (bad_alloc&) {
         return false;
     }
-#endif
 
 
     if (fileSize)
@@ -570,13 +553,7 @@ bool JFileSystem::Rename(string _from, string _to)
     string from = mUserFSPath + _from;
     string to = mUserFSPath + _to;
     std::remove(to.c_str());
-    return (rename(from.c_str(), to.c_str()) == 0);
+    return rename(from.c_str(), to.c_str()) ? true: false;
-}
-
-bool JFileSystem::Remove(string aFile)
-{
-    string toRemove = mUserFSPath + aFile;
-    return (std::remove(toRemove.c_str()) == 0);
 }
 
 int JFileSystem::GetFileSize(izfstream & file)

JGE/src/JGE.cpp

@@ -249,7 +249,6 @@ u32 JGE::BindKey(LocalKeySym sym, JButton button)
 u32 JGE::UnbindKey(LocalKeySym sym, JButton button)
 {
     for (keycodes_it it = keyBinds.begin(); it != keyBinds.end(); )
-    {
         if (sym == it->first && button == it->second)
         {
             keycodes_it er = it;
@@ -257,8 +256,7 @@ u32 JGE::UnbindKey(LocalKeySym sym, JButton button)
             keyBinds.erase(er);
         }
         else ++it;
-    }
+        return keyBinds.size();
-    return keyBinds.size();
 }
 
 u32 JGE::UnbindKey(LocalKeySym sym)
@@ -668,7 +666,7 @@ string JGE::getFileSystemLocation()
     if (env == NULL)
     {
         DebugTrace("An Error Occurred in getting the JNI Environment whie trying to get the system folder location.  Defaulting to /mnt/sdcard/net.wagic.app/Wagic"); 
-    	return "/mnt/sdcard/Wagic/Res";
+    	return "/mnt/sdcard/Wagic";
     };
 
     jclass jniClass = env->FindClass("org/libsdl/app/SDLActivity");
@@ -677,36 +675,7 @@ string JGE::getFileSystemLocation()
     if (methodId == 0)
     {
         DebugTrace("An Error Occurred in getting the JNI methodID for getSystemFolderPath. Defaulting to /mnt/sdcard/Wagic"); 
-    	return "/mnt/sdcard/Wagic/Res";
+    	return "/mnt/sdcard/Wagic";
-    };
-
-    jstring systemPath = (jstring) env->CallStaticObjectMethod(jniClass, methodId);
-
-    // Now convert the Java String to C++ char array
-	const char* cstr = env->GetStringUTFChars(systemPath, 0); 
-	string retVal (cstr);
-	env->ReleaseStringUTFChars(systemPath, cstr); 
-	env->DeleteLocalRef(systemPath);
-
-    return retVal;
-}
-
-string JGE::getFileUserFolderPath()
-{
-    JNIEnv * env = getJNIEnv();
-    if (env == NULL)
-    {
-        DebugTrace("An Error Occurred in getting the JNI Environment whie trying to get the system folder location.  Defaulting to /mnt/sdcard/net.wagic.app/Wagic");
-        return "/mnt/sdcard/Wagic/User";
-    };
-
-    jclass jniClass = env->FindClass("org/libsdl/app/SDLActivity");
-    jmethodID methodId = env->GetStaticMethodID( jniClass, "getUserFolderPath", "()Ljava/lang/String;");
-
-    if (methodId == 0)
-    {
-        DebugTrace("An Error Occurred in getting the JNI methodID for getSystemFolderPath. Defaulting to /mnt/sdcard/Wagic");
-        return "/mnt/sdcard/Wagic/User";
     };
 
     jstring systemPath = (jstring) env->CallStaticObjectMethod(jniClass, methodId);

JGE/src/JGfx-fake.cpp

@@ -65,7 +65,7 @@ void JQuad::SetHotSpot(float x, float y)
 
 //////////////////////////////////////////////////////////////////////////
 
-JTexture::JTexture() : mWidth(0), mHeight(0), mBuffer(NULL)
+JTexture::JTexture() : mBuffer(NULL)
 {
     mTexId = -1;
 }
@@ -305,12 +305,14 @@ void JRenderer::TransferTextureToGLContext(JTexture& inTexture)
 JTexture* JRenderer::CreateTexture(int width, int height, int mode __attribute__((unused)))
 {
     JTexture *tex = new JTexture();
+
     return tex;
 }
 
 JTexture* JRenderer::LoadTexture(const char* filename, int mode, int textureFormat)
 {
     JTexture *tex = new JTexture();
+
     return tex;
 }
 

JGE/src/JGui.cpp

@@ -197,7 +197,7 @@ bool JGuiController::CheckUserInput(JButton key)
                     mObjects[mCurr]->Entering();
                 }
                 mEngine->LeftClickedProcessed();
-                mEngine->ResetInput();
+				mEngine->ResetInput();
                 return true;
             }
             mEngine->LeftClickedProcessed();

JGE/src/JOBJModel.cpp

@@ -75,10 +75,10 @@ bool JOBJModel::Load(const char *modelName, const char *textureName)
 	
 	int count;
 
-	while (filePtr < size)
+    while (filePtr < size)
-	{
+    {
 		filePtr = ReadLine(tmpLine, buffer, filePtr, size);
-		{
+        {
 
 			if ((tmpLine[0] == '#') || (strlen(tmpLine)  < 3))
 			{
@@ -89,19 +89,19 @@ bool JOBJModel::Load(const char *modelName, const char *textureName)
 
 				if (count == 4)
 				{
-					if (string("vn") == s1)
+					if (strcmp(s1, "vn") == 0)
 						normalList.push_back(vert);
-					else if (string("vt") == s1)
+					else if (strcmp(s1, "vt") == 0)
 						texList.push_back(vert);
-					else if (string("v") == s1)
+					else if (strcmp(s1, "v") == 0)
 						vertList.push_back(vert);
 				}
 				else if (count == 3)
 				{
-					if (string("vt") == s1)
+					if (strcmp(s1, "vt") == 0)
 						texList.push_back(vert);
 				}
-				 
+	             
 			}
 			else if (tmpLine[0] == 'f')
 			{
@@ -211,7 +211,7 @@ bool JOBJModel::Load(const char *modelName, const char *textureName)
 	if (textureName != NULL)
 		mTexture = JRenderer::GetInstance()->LoadTexture(textureName);
 
-	return true;
+    return true;
 
 }
 

JGE/src/JParticleEffect.cpp

@@ -90,7 +90,7 @@ bool JParticleEffect::Load(const char* filename)
 // 		FIELD_COUNT
 // 	};
 
-	const string lifeValues[] =
+	const char* lifeValues[] =
 	{
 		"speed",
 		"size",
@@ -104,7 +104,7 @@ bool JParticleEffect::Load(const char* filename)
 		"gravity"
 	};
 
-	const string typeNames[] =
+	const char* typeNames[] =
 	{
 		"POINT",
 		"AREA",
@@ -113,7 +113,7 @@ bool JParticleEffect::Load(const char* filename)
 		"CIRCLE"
 	};
 
-	const string modeNames[] =
+	const char* modeNames[] =
 	{
 		"REPEAT",
 		"ONCE",
@@ -149,32 +149,32 @@ bool JParticleEffect::Load(const char* filename)
 			{
 				element = param->ToElement();
 				
-				if (string("settings") == element->Attribute("name"))
+				if (strcmp(element->Attribute("name"), "settings")==0)
 				{
 					
-					if (string("NORMAL") == element->Attribute("blend"))
+					if (strcmp(element->Attribute("blend"), "NORMAL")==0)
 						mParticleEmitters[mEmitterCount]->SetBlending(BLEND_SRC_ALPHA, BLEND_ONE_MINUS_SRC_ALPHA);
-					else if (string("ADDITIVE") == element->Attribute("blend"))
+					else if (strcmp(element->Attribute("blend"), "ADDITIVE")==0)
 						mParticleEmitters[mEmitterCount]->SetBlending(BLEND_SRC_ALPHA, BLEND_ONE);
 					
 					for (unsigned int i=0;i<sizeof(modeNames)/sizeof(char*);i++)
 					{
-						if (modeNames[i] == element->Attribute("mode"))
+						if (strcmp(element->Attribute("mode"), modeNames[i])==0)
 						{
 							mParticleEmitters[mEmitterCount]->mEmitterMode = i;
 							#if defined (_DEBUG)
-								printf("emitter mode:%s\n", modeNames[i].c_str());
+								printf("emitter mode:%s\n", modeNames[i]);
 							#endif
 							break;
 						}
 					}
 					for (unsigned i=0;i<sizeof(typeNames)/sizeof(char*);i++)
 					{
-						if (typeNames[i] == element->Attribute("type"))
+						if (strcmp(element->Attribute("type"), typeNames[i])==0)
 						{
 							mParticleEmitters[mEmitterCount]->mType = i;
 							#if defined (_DEBUG)
-								printf("emitter type:%s\n", typeNames[i].c_str());
+								printf("emitter type:%s\n", typeNames[i]);
 							#endif
 							break;
 						}
@@ -213,7 +213,7 @@ bool JParticleEffect::Load(const char* filename)
 
 					}
 				}
-				else if (string("quantity") == element->Attribute("name"))
+				else if (strcmp(element->Attribute("name"), "quantity")==0)
 				{
 					for (key = param->FirstChild(); key; key = key->NextSibling())
 					{
@@ -227,7 +227,7 @@ bool JParticleEffect::Load(const char* filename)
 						
 					}
 				}
-				else if (string("lifex") == element->Attribute("name"))
+				else if (strcmp(element->Attribute("name"), "lifex")==0)
 				{
 					if (element->QueryFloatAttribute("base", &baseValue) == TIXML_SUCCESS &&
 						element->QueryFloatAttribute("max", &value) == TIXML_SUCCESS)
@@ -236,7 +236,7 @@ bool JParticleEffect::Load(const char* filename)
 						mParticleEmitters[mEmitterCount]->mLifeMax= value;	
 					}
 				}
-				else if (string("anglex") == element->Attribute("name"))
+				else if (strcmp(element->Attribute("name"), "anglex")==0)
 				{
 					if (element->QueryFloatAttribute("base", &baseValue) == TIXML_SUCCESS &&
 						element->QueryFloatAttribute("max", &value) == TIXML_SUCCESS)
@@ -245,7 +245,7 @@ bool JParticleEffect::Load(const char* filename)
 						mParticleEmitters[mEmitterCount]->mAngleMax= value*DEG2RAD;	
 					}
 				}
-				else if (string("speedx") == element->Attribute("name"))
+				else if (strcmp(element->Attribute("name"), "speedx")==0)
 				{
 					if (element->QueryFloatAttribute("base", &baseValue) == TIXML_SUCCESS &&
 						element->QueryFloatAttribute("max", &value) == TIXML_SUCCESS)
@@ -254,7 +254,7 @@ bool JParticleEffect::Load(const char* filename)
 						mParticleEmitters[mEmitterCount]->mSpeedMax= value;	
 					}
 				}
-				else if (string("sizex") == element->Attribute("name"))
+				else if (strcmp(element->Attribute("name"), "sizex")==0)
 				{
 					if (element->QueryFloatAttribute("base", &baseValue) == TIXML_SUCCESS &&
 						element->QueryFloatAttribute("max", &value) == TIXML_SUCCESS)
@@ -267,7 +267,7 @@ bool JParticleEffect::Load(const char* filename)
 				{
 					for (int i=0;i<FIELD_COUNT;i++)
 					{
-						if (lifeValues[i] == element->Attribute("name"))
+						if (strcmp(element->Attribute("name"), lifeValues[i])==0)
 						{
 							for (key = param->FirstChild(); key; key = key->NextSibling())
 							{

JGE/src/JResourceManager.cpp

@@ -119,11 +119,11 @@ bool JResourceManager::LoadResource(const string& resourceName)
 			element = node->ToElement();
 			if (element != NULL)
 			{
-				if (element->ValueStr() == "texture")
+				if (strcmp(element->Value(), "texture")==0)
 				{
 					CreateTexture(element->Attribute("name"));
 				}
-				else if (element->ValueStr() == "quad")
+				else if (strcmp(element->Value(), "quad")==0)
 				{
 					string quadName = element->Attribute("name");
 					string textureName = element->Attribute("texture");
@@ -170,7 +170,7 @@ bool JResourceManager::LoadResource(const string& resourceName)
 						GetQuad(id)->SetHotSpot(hotspotX, hotspotY);
 					}
 				}
-				else if (element->ValueStr() == "font")
+				else if (strcmp(element->Value(), "font")==0)
 				{
 				}
 

JGE/src/JSpline.cpp

@@ -71,7 +71,7 @@ bool JSpline::Load(const char *filename, float xscale, float yscale)
 		element->QueryFloatAttribute("x", &xx);
 		element->QueryFloatAttribute("y", &yy);
 
-        JPoint pt(xx*xscale, yy*yscale);
+		Point pt(xx*xscale, yy*yscale);
 		AddControlPoint(pt);
 		
 	}
@@ -84,7 +84,7 @@ bool JSpline::Load(const char *filename, float xscale, float yscale)
 
 
 
-void JSpline::PointOnCurve(JPoint &out, float t, const JPoint &p0, const JPoint &p1, const JPoint &p2, const JPoint &p3)
+void JSpline::PointOnCurve(Point &out, float t, const Point &p0, const Point &p1, const Point &p2, const Point &p3)
 {
 	float t2 = t * t;
 	float t3 = t2 * t;
@@ -113,8 +113,8 @@ void JSpline::GeneratePixels()
 	x = mMidPoints[1].x;
 	y = mMidPoints[1].y;
 
-    JPoint newPt(x, y);
+	Point newPt(x, y);
-    JPoint extraPt;
+	Point extraPt;
 
 	mPixels.push_back(newPt);
 
@@ -151,13 +151,13 @@ void JSpline::GeneratePixels()
 }
 
 
-void JSpline::AddControlPoint(const JPoint &pt)
+void JSpline::AddControlPoint(const Point &pt)
 {
 	mMidPoints.push_back(pt);
 }
 
 
-void JSpline::GetControlPoint(JPoint &point, int index)
+void JSpline::GetControlPoint(Point &point, int index)
 {
 	if (index < (int)mMidPoints.size())
 	{
@@ -167,7 +167,7 @@ void JSpline::GetControlPoint(JPoint &point, int index)
 }
 
 
-void JSpline::GetPixel(JPoint &point, int index)
+void JSpline::GetPixel(Point &point, int index)
 {
 	if (index < (int)mPixels.size())
 	{

JGE/src/Qtconsole.cpp

@@ -87,6 +87,8 @@ WagicWrapper::~WagicWrapper()
 
 int main(int argc, char* argv[])
 {
+    QCoreApplication a(argc, argv);
+
     int result = 0;
     WagicWrapper* wagicCore =  new WagicWrapper();
     MTGCollection()->loadFolder("sets/primitives/");
@@ -94,8 +96,9 @@ int main(int argc, char* argv[])
     options.reloadProfile();
     TestSuite testSuite("test/_tests.txt");
     result = testSuite.run();
+    int totalTests = testSuite.nbTests + testSuite.nbAITests;
     delete wagicCore;
-    DebugTrace("TestSuite done: failed test: " << result << " out of " << testSuite.nbTests + testSuite.nbAITests << " total");
+    DebugTrace("TestSuite done: failed test: " << result << " out of " << totalTests << " total");
 #ifdef CAPTURE_STDERR
     OutputCapturer::debugAndClear();
 #endif

JGE/src/Qtmain.cpp

@@ -9,11 +9,11 @@
 #include <QtDeclarative>
 #include "qmlapplicationviewer.h"
 #endif //QT_WIDGET
-#include "Downloader.h"
+#include "filedownloader.h"
 #include "GameApp.h"
 #include "corewrapper.h"
 
-WagicCore* g_glwidget = NULL;
+QWidget* g_glwidget = NULL;
 
 static const struct { LocalKeySym keysym; JButton keycode; } gDefaultBindings[] =
 {
@@ -69,25 +69,18 @@ int main(int argc, char* argv[])
 
 #endif //QT_WIDGET
 
+    if(argc >= 2 && strcmp(argv[1], "testsuite")==0)
+    {
+        int result = 0;
+        result += WagicCore::runTestSuite();
+        return result;
+    }
+
     app->setApplicationName(WagicCore::getApplicationName());
-    DownloadRequest* downloadRequest = NULL;
+    FileDownloader fileDownloader(USERDIR, WAGIC_RESOURCE_NAME);
-#ifdef WAGIC_RESOURCE_URL
-    Downloader*downloader = Downloader::GetInstance();
-    downloadRequest = downloader->Get(
-                "core.zip",
-                WAGIC_RESOURCE_URL
-                );
-#endif
 #ifdef QT_WIDGET
     g_glwidget = new WagicCore();
-    if(!downloadRequest || downloadRequest->getDownloadStatus() == DownloadRequest::DOWNLOADED)
+    g_glwidget->connect(&fileDownloader, SIGNAL(finished(int)), SLOT(start(int)));
-    {
-        g_glwidget->start(0);
-    }
-    else
-    {
-        g_glwidget->connect(downloadRequest, SIGNAL(statusChanged(int)), SLOT(start(int)));
-    }
 #else
     qmlRegisterType<WagicCore>("CustomComponents", 1, 0, "WagicCore");
 

JGE/src/SDLmain.cpp

@@ -18,11 +18,6 @@
 #include <stdexcept>
 #include <iostream>
 #include <math.h>
-#ifndef WIN32
-#include <unistd.h>
-#endif
-#include <stdio.h>
-#include <stdlib.h>
 
 #if (defined FORCE_GLES)
 #undef GL_ES_VERSION_2_0
@@ -58,7 +53,6 @@ JGameLauncher* g_launcher = NULL;
 #ifdef ANDROID
 JNIEnv * mJNIEnv = NULL;
 jclass * mJNIClass = NULL;
-int SDL_ResumeSyncTime = 0;
 #endif
 
 class SdlApp;
@@ -84,21 +78,7 @@ extern "C" void Java_org_libsdl_app_SDLActivity_nativeResume(
 {    
 	if (!g_engine)
 		return;
-    SDL_ResumeSyncTime = 100000;
+	g_engine->Resume();
-    g_engine->Resume();
-}
-
-#include "Wagic_Version.h"
-extern "C" jstring Java_org_libsdl_app_SDLActivity_getResourceName(
-                                       JNIEnv* env, jclass cls)
-{
-    return env->NewStringUTF (WAGIC_RESOURCE_NAME);
-}
-
-extern "C" jstring Java_org_libsdl_app_SDLActivity_getResourceUrl(
-                                       JNIEnv* env, jclass cls)
-{
-    return env->NewStringUTF (WAGIC_RESOURCE_URL);
 }
 #endif
 
@@ -143,16 +123,8 @@ public:
                     if(!g_engine->IsPaused())
                         OnEvent(&Event);
                 }
-                if(!g_engine->IsPaused()){
+                if(!g_engine->IsPaused())
-                    #ifdef ANDROID
-                    // Fix for SDL crash on resuming Android app from background.
-                    if(SDL_ResumeSyncTime){
-                        usleep(SDL_ResumeSyncTime);
-                        SDL_ResumeSyncTime = 0;
-                    }
-                    #endif
                     OnUpdate();
-                }
             }
         }
 
@@ -308,18 +280,17 @@ static const struct { LocalKeySym keysym; JButton keycode; } gDefaultBindings[]
 	{ SDLK_DOWN,          JGE_BTN_DOWN },
 	{ SDLK_LEFT,          JGE_BTN_LEFT },
 	{ SDLK_RIGHT,         JGE_BTN_RIGHT },
-	{ SDLK_w,             JGE_BTN_UP },
+	{ SDLK_z,             JGE_BTN_UP },
-	{ SDLK_s,             JGE_BTN_DOWN },
-	{ SDLK_a,             JGE_BTN_LEFT },
 	{ SDLK_d,             JGE_BTN_RIGHT },
-	{ SDLK_q,             JGE_BTN_PREV },
+	{ SDLK_s,             JGE_BTN_DOWN },
+	{ SDLK_q,             JGE_BTN_LEFT },
+	{ SDLK_a,             JGE_BTN_PREV },
 	{ SDLK_e,             JGE_BTN_NEXT },
 	{ SDLK_i,             JGE_BTN_CANCEL },
 	{ SDLK_l,             JGE_BTN_OK },
 	{ SDLK_SPACE,         JGE_BTN_OK },
 	{ SDLK_k,             JGE_BTN_SEC },
 	{ SDLK_j,             JGE_BTN_PRI },
-	{ SDLK_b,             JGE_BTN_SOUND },
 	{ SDLK_f,             JGE_BTN_FULLSCREEN },
 
 	/* old Qt ones, basically modified to comply with the N900 keyboard

JGE/src/Xmain.cpp

@@ -185,9 +185,9 @@ static const int doubleBufferAttributes[] = {
     GLX_RED_SIZE,      1,     /* the maximum number of bits per component    */
     GLX_GREEN_SIZE,    1,
     GLX_BLUE_SIZE,     1,
-    0L /* None */
+    None
 };
-static int WaitForNotify(Display *dpy, XEvent *event, XPointer arg)
+static Bool WaitForNotify(Display *dpy, XEvent *event, XPointer arg)
 {
   return (event->type == MapNotify) && (event->xmap.window == (Window) arg);
 }
@@ -387,13 +387,13 @@ int main(int argc, char* argv[])
       if (XCheckWindowEvent(gXDisplay, gXWindow, KeyPressMask | KeyReleaseMask | StructureNotifyMask, &event))
 	switch (event.type)
 	  {
-	  case 2: /* KeyPress */
+	  case KeyPress:
             {
               const KeySym sym = XKeycodeToKeysym(gXDisplay, event.xkey.keycode, 1);
               g_engine->HoldKey_NoRepeat(sym);
             }
             break;
-	  case 3: /* KeyRelease */
+	  case KeyRelease:
             g_engine->ReleaseKey(XKeycodeToKeysym(gXDisplay, event.xkey.keycode, 1));
             break;
 	  case ConfigureNotify:

JGE/src/android/JSfx.cpp

@@ -184,13 +184,7 @@ JMusic *JSoundSystem::LoadMusic(const char *fileName)
             const SLboolean req[2] = {SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE};
             result = (*engineEngine)->CreateAudioPlayer(engineEngine, &music->playerObject, &audioSrc, &audioSnk, 2, ids, req);
             DebugTrace("result " << result);
-            
+
-            if(result == SL_RESULT_MEMORY_FAILURE){
-                 delete music;
-                 mCurrentMusic = NULL;
-                 return NULL;
-            }
-            
             // realize the player
             result = (*music->playerObject)->Realize(music->playerObject, SL_BOOLEAN_FALSE);
             DebugTrace("result " << result);
@@ -309,12 +303,6 @@ JSample *JSoundSystem::LoadSample(const char *fileName)
               1, ids, req);
         DebugTrace("result " << result);
 
-        if(result == SL_RESULT_MEMORY_FAILURE){
-             delete sample;
-             mCurrentSample = NULL;
-             return NULL;
-        }
-
         // realize the player
         result = (*sample->playerObject)->Realize(sample->playerObject, SL_BOOLEAN_FALSE);
         DebugTrace("result " << result);

JGE/src/hge/hgeparticle.cpp

@@ -96,8 +96,7 @@ hgeParticleSystem::hgeParticleSystem(hgeParticleSystemInfo *psi)
 {
   //hge=hgeCreate(HGE_VERSION);
 
-	if (psi)
+  memcpy(&info, psi, sizeof(hgeParticleSystemInfo));
-		memcpy(&info, psi, sizeof(hgeParticleSystemInfo));
 
   vecLocation.x=vecPrevLocation.x=0.0f;
   vecLocation.y=vecPrevLocation.y=0.0f;

JGE/src/iOS/EAGLView.m

@@ -166,11 +166,12 @@ void DestroyGame(void)
     [menuKeyRecognizer requireGestureRecognizerToFail: selectKeyRecognizer];
     [self addGestureRecognizer:menuKeyRecognizer];
     
-    /*
+    // initialize the scaling factor
+    lastScale = 1.f;
     UIPinchGestureRecognizer *pinchZoomRecognizer = [[UIPinchGestureRecognizer alloc] initWithTarget:self action:@selector(handlePinchZoom:)];
     [self addGestureRecognizer:pinchZoomRecognizer];
     [pinchZoomRecognizer release];
-    */
+
 
     /*
      Create a single tap recognizer to select the nearest object.
@@ -391,8 +392,6 @@ void DestroyGame(void)
 }
 
 
-
-
 - (BOOL) gestureRecognizer:(UIGestureRecognizer *)gestureRecognizer shouldRecognizeSimultaneouslyWithGestureRecognizer:(UIGestureRecognizer *)otherGestureRecognizer
 {
     return YES;
@@ -425,6 +424,21 @@ void DestroyGame(void)
 }
 
 #pragma mark Gesture Recognizer callbacks
+- (void)handlePinchZoom: (UIPinchGestureRecognizer *) pinchGesture {
+    [[[pinchGesture view] layer] removeAllAnimations];
+    CGFloat currentScaleFactor = [pinchGesture scale];
+
+    if (pinchGesture.state == UIGestureRecognizerStateEnded) {
+        if (lastScale < 1.3f) {
+            lastScale *= currentScaleFactor;
+        }
+        else {
+            lastScale = 1;
+            [self displayGameMenu];
+        }
+        pinchGesture.scale = 1.f;
+    }
+}
 
 - (void)handlePanMotion: (UIPanGestureRecognizer *) panGesture
 {

JGE/src/iOS/EAGLViewController.h

@@ -10,6 +10,5 @@ void resumeGame();
 @property (nonatomic, retain) id eaglView;
 @property (nonatomic, retain) UITextField *inputField;
 @property (nonatomic, assign) BOOL bannerIsVisible;
-- (void)toggleKeyboardWithState: (NSString *) initialText;
 
 @end

JGE/src/iOS/EAGLViewController.m

@@ -47,34 +47,36 @@
 
 - (void)viewDidLoad {
 	NSLog(@"EAGL ViewController - view Did Load");
-
 	[super viewDidLoad];
 }
 
 - (void)viewWillAppear:(BOOL)animated {
 	NSLog(@"EAGL ViewController - view Will Appear");
-    [(id)self.view resumeGame];
+    [self.view resumeGame];
 }
 
-
 - (void)viewWillDisappear:(BOOL)animated
 {
-    [(id)self.view pauseGame];
+    [self.view pauseGame];
 }
 
 - (void)pauseGame
 {
-    [(id)self.view pauseGame];
+    [self.view pauseGame];
 }
 
 - (void)resumeGame
 {
-    [(id)self.view resumeGame];
+    [self.view resumeGame];
 }
 
 - (void)endGame
 {
-    [(id)self.view endGame];
+    [self.view endGame];
+}
+
+- (UIStatusBarStyle)preferredStatusBarStyle {
+    return UIStatusBarStyleLightContent;
 }
 
 - (void)viewDidAppear:(BOOL)animated {

JGE/src/iOS/ES2Renderer.m

@@ -7,6 +7,7 @@
 #include "JFileSystem.h"
 #include "JRenderer.h"
 #include "JGameLauncher.h"
+#include "UIScreen+Util.h"
 
 #define ACTUAL_SCREEN_WIDTH (SCREEN_WIDTH)
 #define ACTUAL_SCREEN_HEIGHT (SCREEN_HEIGHT)
@@ -61,7 +62,7 @@ bool checkFramebufferStatus();
     // for retina devices.  because of the 568 px, the ratio between height-width skews the
     // frame a bit
 
-    if ( backingHeight == 568 || backingWidth == 568) {
+    if ( [UIScreen isRetinaDisplay]) {
 		viewPort.left = 0;
 		viewPort.top = -((backingWidth/ACTUAL_RATIO)-backingHeight)/2  + 22; // account for status bar
 		viewPort.right = backingWidth;

JGE/src/iOS/wagicAppDelegate.m

@@ -337,7 +337,7 @@
 
 - (void)applicationWillTerminate:(UIApplication *)application
 {
-    [(id)self.glViewController.view destroyGame];
+    [self.glViewController.view destroyGame];
 }
 
 - (void)initializeKeyboard: (id) initialState

JGE/src/pc/JGfx.cpp

@@ -343,7 +343,7 @@ void JQuad::SetHotSpot(float x, float y)
 
 //////////////////////////////////////////////////////////////////////////
 
-JTexture::JTexture() : mWidth(0), mHeight(0), mBuffer(NULL)
+JTexture::JTexture() : mBuffer(NULL)
 {
     mTexId = -1;
 }
@@ -1804,7 +1804,7 @@ static void PNGCustomReadDataFn(png_structp png_ptr, png_bytep data, png_size_t
 {
     png_size_t check;
 
-    JFileSystem *fileSystem = (JFileSystem*)png_get_io_ptr(png_ptr);
+    JFileSystem *fileSystem = (JFileSystem*)png_ptr->io_ptr;
 
     check = fileSystem->ReadFile(data, length);
 
@@ -1887,7 +1887,7 @@ int JRenderer::LoadPNG(TextureInfo &textureInfo, const char *filename, int mode
         //fclose(fp);
         fileSystem->CloseFile();
 
-        png_destroy_read_struct(&png_ptr, NULL, NULL);
+        png_destroy_read_struct(&png_ptr, png_infopp_NULL, png_infopp_NULL);
 
         return JGE_ERR_PNG;
     }
@@ -1896,15 +1896,11 @@ int JRenderer::LoadPNG(TextureInfo &textureInfo, const char *filename, int mode
 
     png_set_sig_bytes(png_ptr, sig_read);
     png_read_info(png_ptr, info_ptr);
-    png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, &interlace_type, NULL, NULL);
+    png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, &interlace_type, int_p_NULL, int_p_NULL);
     png_set_strip_16(png_ptr);
     png_set_packing(png_ptr);
     if (color_type == PNG_COLOR_TYPE_PALETTE) png_set_palette_to_rgb(png_ptr);
-#if PNG_LIBPNG_VER >= 10400
-    if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8) png_set_expand_gray_1_2_4_to_8(png_ptr);
-#else
     if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8) png_set_gray_1_2_4_to_8(png_ptr);
-#endif
     if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) png_set_tRNS_to_alpha(png_ptr);
     png_set_filler(png_ptr, 0xff, PNG_FILLER_AFTER);
 
@@ -1914,7 +1910,7 @@ int JRenderer::LoadPNG(TextureInfo &textureInfo, const char *filename, int mode
         //fclose(fp);
         fileSystem->CloseFile();
 
-        png_destroy_read_struct(&png_ptr, NULL, NULL);
+        png_destroy_read_struct(&png_ptr, png_infopp_NULL, png_infopp_NULL);
         return JGE_ERR_MALLOC_FAILED;
     }
 
@@ -1936,7 +1932,7 @@ int JRenderer::LoadPNG(TextureInfo &textureInfo, const char *filename, int mode
 
         for (y = 0; y < (int)height; y++)
         {
-            png_read_row(png_ptr, (BYTE*) line, NULL);
+            png_read_row(png_ptr, (BYTE*) line, png_bytep_NULL);
             for (x = 0; x < (int)width; x++)
             {
                 DWORD color32 = line[x];
@@ -1959,7 +1955,7 @@ int JRenderer::LoadPNG(TextureInfo &textureInfo, const char *filename, int mode
     free (line);
 
     png_read_end(png_ptr, info_ptr);
-    png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+    png_destroy_read_struct(&png_ptr, &info_ptr, png_infopp_NULL);
 
     fileSystem->CloseFile();
 
@@ -2002,15 +1998,8 @@ int JRenderer::image_readgif(void * handle, TextureInfo &textureInfo, DWORD * bg
     GifFileType *GifFileIn = NULL;
     ColorMapObject *palette;
     int ExtCode;
-
-#if GIFLIB_MAJOR >= 5
-    if ((GifFileIn = DGifOpen(handle, readFunc, NULL)) == NULL)
-        return 1;
-#else
     if ((GifFileIn = DGifOpen(handle, readFunc)) == NULL)
         return 1;
-#endif
-
     *bgcolor = 0;
     textureInfo.mWidth = 0;
     textureInfo.mHeight = 0;
@@ -2019,11 +2008,7 @@ int JRenderer::image_readgif(void * handle, TextureInfo &textureInfo, DWORD * bg
     do {
         if (DGifGetRecordType(GifFileIn, &RecordType) == GIF_ERROR)
         {
-#if GIFLIB_MAJOR >= 5
-            DGifCloseFile(GifFileIn, NULL);
-#else
             DGifCloseFile(GifFileIn);
-#endif
             return 1;
         }
 
@@ -2032,20 +2017,12 @@ int JRenderer::image_readgif(void * handle, TextureInfo &textureInfo, DWORD * bg
             {
                 if (DGifGetImageDesc(GifFileIn) == GIF_ERROR)
                 {
-#if GIFLIB_MAJOR >= 5
-                    DGifCloseFile(GifFileIn, NULL);
-#else
                     DGifCloseFile(GifFileIn);
-#endif
                     return 1;
                 }
                 if((palette = (GifFileIn->SColorMap != NULL) ? GifFileIn->SColorMap : GifFileIn->Image.ColorMap) == NULL)
                 {
-#if GIFLIB_MAJOR >= 5
-                    DGifCloseFile(GifFileIn, NULL);
-#else
                     DGifCloseFile(GifFileIn);
-#endif
                     return 1;
                 }
                 textureInfo.mWidth = GifFileIn->Image.Width;
@@ -2053,11 +2030,7 @@ int JRenderer::image_readgif(void * handle, TextureInfo &textureInfo, DWORD * bg
                 *bgcolor = gif_color32(GifFileIn->SBackGroundColor);
                 if((LineIn = (GifRowType) malloc(GifFileIn->Image.Width * sizeof(GifPixelType))) == NULL)
                 {
-#if GIFLIB_MAJOR >= 5
-                    DGifCloseFile(GifFileIn, NULL);
-#else
                     DGifCloseFile(GifFileIn);
-#endif
                     return 1;
                 }
                 textureInfo.mTexWidth = getNextPower2(GifFileIn->Image.Width);
@@ -2067,11 +2040,7 @@ int JRenderer::image_readgif(void * handle, TextureInfo &textureInfo, DWORD * bg
                 if((p32 = (DWORD *)malloc(sizeof(PIXEL_TYPE) * textureInfo.mTexWidth * textureInfo.mTexHeight)) == NULL)
                 {
                     free((void *)LineIn);
-#if GIFLIB_MAJOR >= 5
-                    DGifCloseFile(GifFileIn, NULL);
-#else
                     DGifCloseFile(GifFileIn);
-#endif
                     return 1;
                 }
                 DWORD * curr = p32;
@@ -2083,11 +2052,7 @@ int JRenderer::image_readgif(void * handle, TextureInfo &textureInfo, DWORD * bg
                     {
                         free((void *)p32);
                         free((void *)LineIn);
-#if GIFLIB_MAJOR >= 5
-                        DGifCloseFile(GifFileIn, NULL);
-#else
                         DGifCloseFile(GifFileIn);
-#endif
                         return 1;
                     }
                     for (GifWord j = 0; j < GifFileIn->Image.Width; j ++)
@@ -2116,11 +2081,7 @@ int JRenderer::image_readgif(void * handle, TextureInfo &textureInfo, DWORD * bg
                 }
                 if(LineIn != NULL)
                     free((void *)LineIn);
-#if GIFLIB_MAJOR >= 5
-                DGifCloseFile(GifFileIn, NULL);
-#else
                 DGifCloseFile(GifFileIn);
-#endif
                 return 1;
             }
             while (Extension != NULL) {
@@ -2133,11 +2094,7 @@ int JRenderer::image_readgif(void * handle, TextureInfo &textureInfo, DWORD * bg
                     }
                     if(LineIn != NULL)
                         free((void *)LineIn);
-#if GIFLIB_MAJOR >= 5
-                    DGifCloseFile(GifFileIn, NULL);
-#else
                     DGifCloseFile(GifFileIn);
-#endif
                     return 1;
                 }
             }
@@ -2152,11 +2109,7 @@ int JRenderer::image_readgif(void * handle, TextureInfo &textureInfo, DWORD * bg
 
     if(LineIn != NULL)
         free((void *)LineIn);
-#if GIFLIB_MAJOR >= 5
-    DGifCloseFile(GifFileIn, NULL);
-#else
     DGifCloseFile(GifFileIn);
-#endif
 
     return 0;
 }
@@ -2533,7 +2486,7 @@ void JRenderer::Enable2D()
 #if (defined GL_VERSION_ES_CM_1_1) || (defined GL_OES_VERSION_1_1)
     glOrthof(0.0f, SCREEN_WIDTH_F, 0.0f, SCREEN_HEIGHT_F-1.0f, -1.0f, 1.0f);
 #else
-    glOrtho(0.0f, SCREEN_WIDTH_F, 0.0f, SCREEN_HEIGHT_F-1.0f, -1.0f, 1.0f);
+    gluOrtho2D(0.0f, SCREEN_WIDTH_F, 0.0f, SCREEN_HEIGHT_F-1.0f);
 #endif
 
     glMatrixMode (GL_MODELVIEW);										// Select The Modelview Matrix

JGE/src/pc/JSfx.cpp

@@ -22,8 +22,6 @@
 JMusic::JMusic()
 #ifdef USE_PHONON
   : mOutput(0), mMediaObject(0)
-#elif defined QT_CONFIG
-    : playlist(0), player(0)
 #endif
 {
 }
@@ -42,16 +40,11 @@ int JMusic::getPlayTime(){
 
 JMusic::~JMusic()
 {
-#if defined USE_PHONON
+#ifdef USE_PHONON
   if(mOutput)
     delete mOutput;
   if(mMediaObject)
     delete mMediaObject;
-#elif defined QT_CONFIG
-    if(player)
-        delete player;
-    if(playlist)
-        delete playlist;
 #elif defined WITH_FMOD
   JSoundSystem::GetInstance()->StopMusic(this);
   if (mTrack) FSOUND_Sample_Free(mTrack);
@@ -76,10 +69,7 @@ JSample::JSample()
 
 JSample::~JSample()
 {
-#if (defined QT_CONFIG) && (!defined USE_PHONON)
+#ifdef USE_PHONON
-    if(effect)
-        delete effect;
-#elif USE_PHONON
   if(mOutput)
     delete mOutput;
   if(mMediaObject)
@@ -154,84 +144,65 @@ void JSoundSystem::DestroySoundSystem()
 
 JMusic *JSoundSystem::LoadMusic(const char *fileName)
 {
-    JMusic* music = NULL;
+#ifdef USE_PHONON
-#if (defined QT_CONFIG)  && (!defined USE_PHONON)
+  JMusic* music = new JMusic();
-    music = new JMusic();
+  if (music)
-    if (music)
+  {
-    {
+    music->mOutput = new Phonon::AudioOutput(Phonon::GameCategory, 0);
-        music->player = new QMediaPlayer;
+    music->mMediaObject = new Phonon::MediaObject(0);
-        music->player->setVolume(100);
+    string fullpath = JFileSystem::GetInstance()->GetResourceFile(fileName);
-        music->playlist = new QMediaPlaylist;
+    music->mMediaObject->setCurrentSource(QString(fullpath.c_str()));
-        music->fullpath = JFileSystem::GetInstance()->GetResourceFile(fileName);
+    Phonon::Path mediapath = Phonon::createPath(music->mMediaObject, music->mOutput);
-        music->playlist->addMedia(QUrl::fromLocalFile(music->fullpath.c_str()));
+    Q_ASSERT(mediapath.isValid());
-        music->playlist->setCurrentIndex(0);
+  }
-    }
+  return music;
-#elif defined USE_PHONON
-    music = new JMusic();
-    if (music)
-    {
-        music->mOutput = new Phonon::AudioOutput(Phonon::GameCategory, 0);
-        music->mMediaObject = new Phonon::MediaObject(0);
-        string fullpath = JFileSystem::GetInstance()->GetResourceFile(fileName);
-        music->mMediaObject->setCurrentSource(QString(fullpath.c_str()));
-        Phonon::Path mediapath = Phonon::createPath(music->mMediaObject, music->mOutput);
-        Q_ASSERT(mediapath.isValid());
-    }
 #elif (defined WITH_FMOD)
-    music = new JMusic();
+  JMusic* music = new JMusic();
-    if (music)
+  if (music)
     {
-        JFileSystem* fileSystem = JFileSystem::GetInstance();
+      JFileSystem* fileSystem = JFileSystem::GetInstance();
-        if (fileSystem->OpenFile(fileName))
+      if (fileSystem->OpenFile(fileName))
-        {
+	{
-            int size = fileSystem->GetFileSize();
+	  int size = fileSystem->GetFileSize();
-            char *buffer = new char[size];
+	  char *buffer = new char[size];
-            fileSystem->ReadFile(buffer, size);
+	  fileSystem->ReadFile(buffer, size);
-            music->mTrack = FSOUND_Sample_Load(FSOUND_UNMANAGED, buffer, FSOUND_LOADMEMORY, 0, size);
+	  music->mTrack = FSOUND_Sample_Load(FSOUND_UNMANAGED, buffer, FSOUND_LOADMEMORY, 0, size);
 
-            delete[] buffer;
+	  delete[] buffer;
-            fileSystem->CloseFile();
+	  fileSystem->CloseFile();
-        }
+	}
     }
+  return music;
 #else
     cerr << fileName << endl;
+  return NULL;
 #endif
-    return music;
 }
 
 
 void JSoundSystem::PlayMusic(JMusic *music, bool looping)
 {
-#if (defined QT_CONFIG)  && (!defined USE_PHONON)
+#ifdef USE_PHONON
-    if(music && music->player && music->playlist)
+  if (music && music->mMediaObject && music->mOutput)
+  {
+    if(looping)
     {
-        if(looping)
+      music->mMediaObject->connect(music->mMediaObject, SIGNAL(aboutToFinish()), music, SLOT(seekAtTheBegining()));
-            music->playlist->setPlaybackMode(QMediaPlaylist::Loop);
-
-        music->player->setPlaylist(music->playlist);
-        music->player->play();
     }
-#elif USE_PHONON
+    music->mOutput->setVolume((qreal)mVolume*0.01);
-    if (music && music->mMediaObject && music->mOutput)
+    music->mMediaObject->play();
-    {
-        if(looping)
-        {
-            music->mMediaObject->connect(music->mMediaObject, SIGNAL(aboutToFinish()), music, SLOT(seekAtTheBegining()));
-        }
-        music->mOutput->setVolume((qreal)mVolume*0.01);
-        music->mMediaObject->play();
 
-    }
+  }
 #elif (defined WITH_FMOD)
-    if (music && music->mTrack)
+  if (music && music->mTrack)
     {
-        mChannel = FSOUND_PlaySound(mChannel, music->mTrack);
+      mChannel = FSOUND_PlaySound(mChannel, music->mTrack);
-        SetMusicVolume(mVolume);
+      SetMusicVolume(mVolume);
 
-        if (looping)
+      if (looping)
-            FSOUND_SetLoopMode(mChannel, FSOUND_LOOP_NORMAL);
+	FSOUND_SetLoopMode(mChannel, FSOUND_LOOP_NORMAL);
-        else
+      else
-            FSOUND_SetLoopMode(mChannel, FSOUND_LOOP_OFF);
+	FSOUND_SetLoopMode(mChannel, FSOUND_LOOP_OFF);
     }
 #else
     music = 0;
@@ -242,12 +213,7 @@ void JSoundSystem::PlayMusic(JMusic *music, bool looping)
 
 void JSoundSystem::StopMusic(JMusic *music)
 {
-#if (defined QT_CONFIG) && (!defined USE_PHONON)
+#ifdef USE_PHONON
-    if (music && music->player && music->playlist)
-    {
-        music->player->stop();
-    }
-#elif defined USE_PHONON
   if (music && music->mMediaObject && music->mOutput)
   {
     music->mMediaObject->stop();
@@ -298,61 +264,47 @@ void JSoundSystem::SetSfxVolume(int volume){
 
 JSample *JSoundSystem::LoadSample(const char *fileName)
 {
-    JSample* sample = NULL;
+#if (defined USE_PHONON)
-#if (defined QT_CONFIG) && (!defined USE_PHONON)
+  JSample* sample = new JSample();
-    sample = new JSample();
+  if (sample)
-    if (sample)
+  {
-    {
+    sample->mOutput = new Phonon::AudioOutput(Phonon::GameCategory, 0);
-        string fullpath = JFileSystem::GetInstance()->GetResourceFile(fileName);
+    sample->mMediaObject = new Phonon::MediaObject(0);
-        sample->effect = new QMediaPlayer;
+    string fullpath = JFileSystem::GetInstance()->GetResourceFile(fileName);
-        sample->effect->setMedia(QUrl::fromLocalFile(fullpath.c_str()));
+    sample->mMediaObject->setCurrentSource(QString(fullpath.c_str()));
-        sample->effect->setVolume(100);
+    Phonon::Path mediapath = Phonon::createPath(sample->mMediaObject, sample->mOutput);
-        sample->mSample = &(sample->effect);
+    Q_ASSERT(mediapath.isValid());
-    }
+  }
-#elif (defined USE_PHONON)
+  return sample;
-    sample = new JSample();
-    if (sample)
-    {
-        sample->mOutput = new Phonon::AudioOutput(Phonon::GameCategory, 0);
-        sample->mMediaObject = new Phonon::MediaObject(0);
-        string fullpath = JFileSystem::GetInstance()->GetResourceFile(fileName);
-        sample->mMediaObject->setCurrentSource(QString(fullpath.c_str()));
-        Phonon::Path mediapath = Phonon::createPath(sample->mMediaObject, sample->mOutput);
-        Q_ASSERT(mediapath.isValid());
-    }
 #elif (defined WITH_FMOD)
-    sample = new JSample();
+  JSample* sample = new JSample();
-    if (sample)
+  if (sample)
     {
-        JFileSystem* fileSystem = JFileSystem::GetInstance();
+      JFileSystem* fileSystem = JFileSystem::GetInstance();
-        if (fileSystem->OpenFile(fileName))
+      if (fileSystem->OpenFile(fileName))
-        {
+	{
-            int size = fileSystem->GetFileSize();
+	  int size = fileSystem->GetFileSize();
-            char *buffer = new char[size];
+	  char *buffer = new char[size];
-            fileSystem->ReadFile(buffer, size);
+	  fileSystem->ReadFile(buffer, size);
-            sample->mSample = FSOUND_Sample_Load(FSOUND_UNMANAGED, buffer, FSOUND_LOADMEMORY, 0, size);
+	  sample->mSample = FSOUND_Sample_Load(FSOUND_UNMANAGED, buffer, FSOUND_LOADMEMORY, 0, size);
 
-            delete[] buffer;
+	  delete[] buffer;
-            fileSystem->CloseFile();
+	  fileSystem->CloseFile();
-        }else
+	}else
-            sample->mSample = NULL;
+	sample->mSample = NULL;
 
     }
+  return sample;
 #else
     cerr << fileName << endl;
+  return NULL;
 #endif
-    return sample;
 }
 
 
 void JSoundSystem::PlaySample(JSample *sample)
 {
-#if (defined QT_CONFIG) && (!defined USE_PHONON)
+#ifdef USE_PHONON
-    if(sample)
-    {
-        sample->effect->play();
-    }
-#elif defined USE_PHONON
   if (sample && sample->mMediaObject && sample->mOutput)
   {
     sample->mOutput->setVolume((qreal)mSampleVolume*0.01);

JGE/src/pc/JSocket.cpp

@@ -7,7 +7,6 @@
 #include <winsock.h>
 #include <fcntl.h>
 #elif LINUX
-#include <unistd.h>
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <netinet/in.h>
@@ -48,9 +47,7 @@ JSocket::JSocket(string ipAddr)
 
 #ifdef WIN32
 	unsigned int addr_dest = inet_addr(ipAddr.c_str());
-	hostentptr = gethostbyaddr((char*) &addr_dest, 4, AF_INET);
+	hostentptr=gethostbyaddr((char*) &addr_dest, 4, AF_INET);
-	if (hostentptr == NULL)
-	    hostentptr = gethostbyname(ipAddr.c_str()); // Fix for Windows if IP Address cannot be resolved.
 #elif LINUX
 	hostentptr = gethostbyname(ipAddr.c_str());
 #endif

JGE/src/qt/corewrapper.cpp

@@ -335,7 +335,7 @@ void WagicCore::resizeGL(int width, int height)
 #if (defined GL_VERSION_ES_CM_1_1 || defined GL_OES_VERSION_1_1)
     glOrthof(0.0f, (float) (m_viewPort.right()-m_viewPort.left())-1.0f, 0.0f, (float) (m_viewPort.bottom()-m_viewPort.top())-1.0f, -1.0f, 1.0f);
 #else
-    glOrtho(0.0f, (float) (m_viewPort.right()-m_viewPort.left())-1.0f, 0.0f, (float) (m_viewPort.bottom()-m_viewPort.top())-1.0f, -1.0f, 1.0f);
+    gluOrtho2D(0.0f, (float) (m_viewPort.right()-m_viewPort.left())-1.0f, 0.0f, (float) (m_viewPort.bottom()-m_viewPort.top())-1.0f);
 #endif
 
     glMatrixMode (GL_MODELVIEW);										// Select The Modelview Matrix
@@ -418,29 +418,29 @@ void WagicCore::mousePressEvent(QMouseEvent *event)
 {
   if(event->button() == Qt::LeftButton)
   {
-    m_lastPos = event->pos();
+    QPoint lastPos = event->pos();
     // this is intended to convert window coordinate into game coordinate.
     // this is correct only if the game and window have the same aspect ratio, otherwise, it's just wrong
     int actualWidth = (int) JRenderer::GetInstance()->GetActualWidth();
     int actualHeight = (int) JRenderer::GetInstance()->GetActualHeight();
 
-    if (lastPosy() >= m_viewPort.top() &&
+    if (lastPos.y() >= m_viewPort.top() &&
-      lastPosy() <= m_viewPort.bottom() &&
+      lastPos.y() <= m_viewPort.bottom() &&
-      lastPosx() <= m_viewPort.right() &&
+      lastPos.x() <= m_viewPort.right() &&
-      lastPosx() >= m_viewPort.left()) {
+      lastPos.x() >= m_viewPort.left()) {
       m_engine->LeftClicked(
-                  ((lastPosx()-m_viewPort.left())*SCREEN_WIDTH)/actualWidth,
+                  ((lastPos.x()-m_viewPort.left())*SCREEN_WIDTH)/actualWidth,
-                  ((lastPosy()-m_viewPort.top())*SCREEN_HEIGHT)/actualHeight);
+                  ((lastPos.y()-m_viewPort.top())*SCREEN_HEIGHT)/actualHeight);
 #if (!defined Q_WS_MAEMO_5) && (!defined MEEGO_EDITION_HARMATTAN) && (!defined Q_WS_ANDROID)
       m_engine->HoldKey_NoRepeat(JGE_BTN_OK);
 #else
-      mMouseDownX = lastPosx();
+      mMouseDownX = lastPos.x();
-      mMouseDownY = lastPosy();
+      mMouseDownY = lastPos.y();
       mLastFingerDownTime = g_startTimer.elapsed();
 #endif
-    } else if(lastPosy()<m_viewPort.top()) {
+    } else if(lastPos.y()<m_viewPort.top()) {
       m_engine->HoldKey_NoRepeat(JGE_BTN_MENU);
-    } else if(lastPosy()>m_viewPort.bottom()) {
+    } else if(lastPos.y()>m_viewPort.bottom()) {
       m_engine->HoldKey_NoRepeat(JGE_BTN_NEXT);
     }
     event->accept();
@@ -465,33 +465,33 @@ void WagicCore::mouseReleaseEvent(QMouseEvent *event)
 {
   if(event->button() == Qt::LeftButton)
   {
-    m_lastPos = event->pos();
+    QPoint lastPos = event->pos();
 
-    if (lastPosy() >= m_viewPort.top() &&
+    if (lastPos.y() >= m_viewPort.top() &&
-      lastPosy() <= m_viewPort.bottom() &&
+      lastPos.y() <= m_viewPort.bottom() &&
-      lastPosx() <= m_viewPort.right() &&
+      lastPos.x() <= m_viewPort.right() &&
-      lastPosx() >= m_viewPort.left()) {
+      lastPos.x() >= m_viewPort.left()) {
 #if (defined Q_WS_MAEMO_5) || (defined MEEGO_EDITION_HARMATTAN) || (defined Q_WS_ANDROID)
       if(g_startTimer.elapsed() - mLastFingerDownTime <= kTapEventTimeout )
       {
-        if(abs(mMouseDownX - lastPosx()) < kHitzonePliancy &&
+        if(abs(mMouseDownX - lastPos.x()) < kHitzonePliancy &&
-           abs(mMouseDownY - lastPosy()) < kHitzonePliancy)
+           abs(mMouseDownY - lastPos.y()) < kHitzonePliancy)
         {
           m_engine->HoldKey_NoRepeat(JGE_BTN_OK);
         }
       }
       else if (g_startTimer.elapsed() - mLastFingerDownTime >= kSwipeEventMinDuration)
       { // Let's swipe
-        m_engine->Scroll(lastPosx()-mMouseDownX, lastPosy()-mMouseDownY);
+        m_engine->Scroll(lastPos.x()-mMouseDownX, lastPos.y()-mMouseDownY);
       }
 #else
 //#if (!defined Q_WS_MAEMO_5) && (!defined MEEGO_EDITION_HARMATTAN)
       m_engine->ReleaseKey(JGE_BTN_OK);
 #endif
       m_engine->ReleaseKey(JGE_BTN_MENU);
-    } else if(lastPosy() < m_viewPort.top()) {
+    } else if(lastPos.y() < m_viewPort.top()) {
       m_engine->ReleaseKey(JGE_BTN_MENU);
-    } else if(lastPosy() > m_viewPort.bottom()) {
+    } else if(lastPos.y() > m_viewPort.bottom()) {
       m_engine->ReleaseKey(JGE_BTN_NEXT);
     }
     event->accept();
@@ -517,15 +517,15 @@ void WagicCore::mouseMoveEvent(QMouseEvent *event)
   int actualWidth = (int) JRenderer::GetInstance()->GetActualWidth();
   int actualHeight = (int) JRenderer::GetInstance()->GetActualHeight();
 
-  m_lastPos = event->pos();
+  QPoint lastPos = event->pos();
 
-  if (lastPosy() >= m_viewPort.top() &&
+  if (lastPos.y() >= m_viewPort.top() &&
-    lastPosy() <= m_viewPort.bottom() &&
+    lastPos.y() <= m_viewPort.bottom() &&
-    lastPosx() <= m_viewPort.right() &&
+    lastPos.x() <= m_viewPort.right() &&
-    lastPosx() >= m_viewPort.left()) {
+    lastPos.x() >= m_viewPort.left()) {
     m_engine->LeftClicked(
-                ((lastPosx()-m_viewPort.left())*SCREEN_WIDTH)/actualWidth,
+                ((lastPos.x()-m_viewPort.left())*SCREEN_WIDTH)/actualWidth,
-                ((lastPosy()-m_viewPort.top())*SCREEN_HEIGHT)/actualHeight);
+                ((lastPos.y()-m_viewPort.top())*SCREEN_HEIGHT)/actualHeight);
     event->accept();
   } else {
     super::mouseMoveEvent(event);

JGE/src/unzip/crypt.h

@@ -87,13 +87,13 @@ static void init_keys(const char* passwd,unsigned long* pkeys,const unsigned lon
 #    define ZCR_SEED2 3141592654UL     /* use PI as default pattern */
 #  endif
 
-static int crypthead(
+static int crypthead(passwd, buf, bufSize, pkeys, pcrc_32_tab, crcForCrypting)
-    const char *passwd,         /* password string */
+    const char *passwd;         /* password string */
-    unsigned char *buf,         /* where to write header */
+    unsigned char *buf;         /* where to write header */
-    int bufSize,
+    int bufSize;
-    unsigned long* pkeys,
+    unsigned long* pkeys;
-    const unsigned long* pcrc_32_tab,
+    const unsigned long* pcrc_32_tab;
-    unsigned long crcForCrypting)
+    unsigned long crcForCrypting;
 {
     int n;                       /* index in random header */
     int t;                       /* temporary */

JGE/src/unzip/ioapi.c

@@ -65,10 +65,10 @@ int ZCALLBACK ferror_file_func OF((
    voidpf stream));
 
 
-voidpf ZCALLBACK fopen_file_func (
+voidpf ZCALLBACK fopen_file_func (opaque, filename, mode)
-   voidpf opaque,
+   voidpf opaque;
-   const char* filename,
+   const char* filename;
-   int mode)
+   int mode;
 {
     FILE* file = NULL;
     const char* mode_fopen = NULL;
@@ -87,11 +87,11 @@ voidpf ZCALLBACK fopen_file_func (
 }
 
 
-uLong ZCALLBACK fread_file_func (
+uLong ZCALLBACK fread_file_func (opaque, stream, buf, size)
-   voidpf opaque,
+   voidpf opaque;
-   voidpf stream,
+   voidpf stream;
-   void* buf,
+   void* buf;
-   uLong size)
+   uLong size;
 {
     uLong ret;
     ret = (uLong)fread(buf, 1, (size_t)size, (FILE *)stream);
@@ -99,31 +99,31 @@ uLong ZCALLBACK fread_file_func (
 }
 
 
-uLong ZCALLBACK fwrite_file_func (
+uLong ZCALLBACK fwrite_file_func (opaque, stream, buf, size)
-   voidpf opaque,
+   voidpf opaque;
-   voidpf stream,
+   voidpf stream;
-   const void* buf,
+   const void* buf;
-   uLong size)
+   uLong size;
 {
     uLong ret;
     ret = (uLong)fwrite(buf, 1, (size_t)size, (FILE *)stream);
     return ret;
 }
 
-long ZCALLBACK ftell_file_func (
+long ZCALLBACK ftell_file_func (opaque, stream)
-   voidpf opaque,
+   voidpf opaque;
-   voidpf stream)
+   voidpf stream;
 {
     long ret;
     ret = ftell((FILE *)stream);
     return ret;
 }
 
-long ZCALLBACK fseek_file_func (
+long ZCALLBACK fseek_file_func (opaque, stream, offset, origin)
-   voidpf opaque,
+   voidpf opaque;
-   voidpf stream,
+   voidpf stream;
-   uLong offset,
+   uLong offset;
-   int origin)
+   int origin;
 {
     int fseek_origin=0;
     long ret;
@@ -145,26 +145,26 @@ long ZCALLBACK fseek_file_func (
     return ret;
 }
 
-int ZCALLBACK fclose_file_func (
+int ZCALLBACK fclose_file_func (opaque, stream)
-   voidpf opaque,
+   voidpf opaque;
-   voidpf stream)
+   voidpf stream;
 {
     int ret;
     ret = fclose((FILE *)stream);
     return ret;
 }
 
-int ZCALLBACK ferror_file_func (
+int ZCALLBACK ferror_file_func (opaque, stream)
-   voidpf opaque,
+   voidpf opaque;
-   voidpf stream)
+   voidpf stream;
 {
     int ret;
     ret = ferror((FILE *)stream);
     return ret;
 }
 
-void fill_fopen_filefunc (
+void fill_fopen_filefunc (pzlib_filefunc_def)
-  zlib_filefunc_def* pzlib_filefunc_def)
+  zlib_filefunc_def* pzlib_filefunc_def;
 {
     pzlib_filefunc_def->zopen_file = fopen_file_func;
     pzlib_filefunc_def->zread_file = fread_file_func;

JGE/src/unzip/unzip.c

@@ -168,7 +168,10 @@ local int unzlocal_getByte OF((
     voidpf filestream,
     int *pi));
 
-local int unzlocal_getByte(const zlib_filefunc_def* pzlib_filefunc_def,voidpf filestream,int *pi)
+local int unzlocal_getByte(pzlib_filefunc_def,filestream,pi)
+    const zlib_filefunc_def* pzlib_filefunc_def;
+    voidpf filestream;
+    int *pi;
 {
     unsigned char c;
     int err = (int)ZREAD(*pzlib_filefunc_def,filestream,&c,1);
@@ -195,7 +198,10 @@ local int unzlocal_getShort OF((
     voidpf filestream,
     uLong *pX));
 
-local int unzlocal_getShort (const zlib_filefunc_def* pzlib_filefunc_def,voidpf filestream,uLong *pX)
+local int unzlocal_getShort (pzlib_filefunc_def,filestream,pX)
+    const zlib_filefunc_def* pzlib_filefunc_def;
+    voidpf filestream;
+    uLong *pX;
 {
     uLong x ;
     int i;
@@ -220,7 +226,10 @@ local int unzlocal_getLong OF((
     voidpf filestream,
     uLong *pX));
 
-local int unzlocal_getLong (const zlib_filefunc_def* pzlib_filefunc_def,voidpf filestream,uLong *pX)
+local int unzlocal_getLong (pzlib_filefunc_def,filestream,pX)
+    const zlib_filefunc_def* pzlib_filefunc_def;
+    voidpf filestream;
+    uLong *pX;
 {
     uLong x ;
     int i;
@@ -250,7 +259,9 @@ local int unzlocal_getLong (const zlib_filefunc_def* pzlib_filefunc_def,voidpf f
 
 
 /* My own strcmpi / strcasecmp */
-local int strcmpcasenosensitive_internal (const char* fileName1,const char* fileName2)
+local int strcmpcasenosensitive_internal (fileName1,fileName2)
+    const char* fileName1;
+    const char* fileName2;
 {
     for (;;)
     {
@@ -291,7 +302,10 @@ local int strcmpcasenosensitive_internal (const char* fileName1,const char* file
         (like 1 on Unix, 2 on Windows)
 
 */
-extern int ZEXPORT unzStringFileNameCompare (const char* fileName1,const char* fileName2,int iCaseSensitivity)
+extern int ZEXPORT unzStringFileNameCompare (fileName1,fileName2,iCaseSensitivity)
+    const char* fileName1;
+    const char* fileName2;
+    int iCaseSensitivity;
 {
     if (iCaseSensitivity==0)
         iCaseSensitivity=CASESENSITIVITYDEFAULTVALUE;
@@ -314,7 +328,9 @@ local uLong unzlocal_SearchCentralDir OF((
     const zlib_filefunc_def* pzlib_filefunc_def,
     voidpf filestream));
 
-local uLong unzlocal_SearchCentralDir(const zlib_filefunc_def* pzlib_filefunc_def,voidpf filestream)
+local uLong unzlocal_SearchCentralDir(pzlib_filefunc_def,filestream)
+    const zlib_filefunc_def* pzlib_filefunc_def;
+    voidpf filestream;
 {
     unsigned char* buf;
     uLong uSizeFile;
@@ -378,7 +394,9 @@ local uLong unzlocal_SearchCentralDir(const zlib_filefunc_def* pzlib_filefunc_de
      Else, the return value is a unzFile Handle, usable with other function
        of this unzip package.
 */
-extern unzFile ZEXPORT unzOpen2 (const char *path, zlib_filefunc_def* pzlib_filefunc_def)
+extern unzFile ZEXPORT unzOpen2 (path, pzlib_filefunc_def)
+    const char *path;
+    zlib_filefunc_def* pzlib_filefunc_def;
 {
     unz_s us;
     unz_s *s;
@@ -479,7 +497,8 @@ extern unzFile ZEXPORT unzOpen2 (const char *path, zlib_filefunc_def* pzlib_file
 }
 
 
-extern unzFile ZEXPORT unzOpen (const char *path)
+extern unzFile ZEXPORT unzOpen (path)
+    const char *path;
 {
     return unzOpen2(path, NULL);
 }
@@ -489,7 +508,8 @@ extern unzFile ZEXPORT unzOpen (const char *path)
   If there is files inside the .Zip opened with unzipOpenCurrentFile (see later),
     these files MUST be closed with unzipCloseCurrentFile before call unzipClose.
   return UNZ_OK if there is no problem. */
-extern int ZEXPORT unzClose (unzFile file)
+extern int ZEXPORT unzClose (file)
+    unzFile file;
 {
     unz_s* s;
     if (file==NULL)
@@ -509,7 +529,9 @@ extern int ZEXPORT unzClose (unzFile file)
   Write info about the ZipFile in the *pglobal_info structure.
   No preparation of the structure is needed
   return UNZ_OK if there is no problem. */
-extern int ZEXPORT unzGetGlobalInfo (unzFile file,unz_global_info *pglobal_info)
+extern int ZEXPORT unzGetGlobalInfo (file,pglobal_info)
+    unzFile file;
+    unz_global_info *pglobal_info;
 {
     unz_s* s;
     if (file==NULL)
@@ -523,7 +545,9 @@ extern int ZEXPORT unzGetGlobalInfo (unzFile file,unz_global_info *pglobal_info)
 /*
    Translate date/time from Dos format to tm_unz (readable more easilty)
 */
-local void unzlocal_DosDateToTmuDate (uLong ulDosDate, tm_unz* ptm)
+local void unzlocal_DosDateToTmuDate (ulDosDate, ptm)
+    uLong ulDosDate;
+    tm_unz* ptm;
 {
     uLong uDate;
     uDate = (uLong)(ulDosDate>>16);
@@ -550,16 +574,21 @@ local int unzlocal_GetCurrentFileInfoInternal OF((unzFile file,
                                                   char *szComment,
                                                   uLong commentBufferSize));
 
-local int unzlocal_GetCurrentFileInfoInternal (
+local int unzlocal_GetCurrentFileInfoInternal (file,
-    unzFile file,
+                                              pfile_info,
-    unz_file_info *pfile_info,
+                                              pfile_info_internal,
-    unz_file_info_internal *pfile_info_internal,
+                                              szFileName, fileNameBufferSize,
-    char *szFileName,
+                                              extraField, extraFieldBufferSize,
-    uLong fileNameBufferSize,
+                                              szComment,  commentBufferSize)
-    void *extraField,
+    unzFile file;
-    uLong extraFieldBufferSize,
+    unz_file_info *pfile_info;
-    char *szComment,
+    unz_file_info_internal *pfile_info_internal;
-    uLong commentBufferSize)
+    char *szFileName;
+    uLong fileNameBufferSize;
+    void *extraField;
+    uLong extraFieldBufferSize;
+    char *szComment;
+    uLong commentBufferSize;
 {
     unz_s* s;
     unz_file_info file_info;
@@ -717,15 +746,19 @@ local int unzlocal_GetCurrentFileInfoInternal (
   No preparation of the structure is needed
   return UNZ_OK if there is no problem.
 */
-extern int ZEXPORT unzGetCurrentFileInfo (
+extern int ZEXPORT unzGetCurrentFileInfo (file,
-    unzFile file,
+                                          pfile_info,
-    unz_file_info *pfile_info,
+                                          szFileName, fileNameBufferSize,
-    char *szFileName,
+                                          extraField, extraFieldBufferSize,
-    uLong fileNameBufferSize,
+                                          szComment,  commentBufferSize)
-    void *extraField,
+    unzFile file;
-    uLong extraFieldBufferSize,
+    unz_file_info *pfile_info;
-    char *szComment,
+    char *szFileName;
-    uLong commentBufferSize)
+    uLong fileNameBufferSize;
+    void *extraField;
+    uLong extraFieldBufferSize;
+    char *szComment;
+    uLong commentBufferSize;
 {
     return unzlocal_GetCurrentFileInfoInternal(file,pfile_info,NULL,
                                                 szFileName,fileNameBufferSize,
@@ -737,7 +770,8 @@ extern int ZEXPORT unzGetCurrentFileInfo (
   Set the current file of the zipfile to the first file.
   return UNZ_OK if there is no problem
 */
-extern int ZEXPORT unzGoToFirstFile (unzFile file)
+extern int ZEXPORT unzGoToFirstFile (file)
+    unzFile file;
 {
     int err=UNZ_OK;
     unz_s* s;
@@ -758,7 +792,8 @@ extern int ZEXPORT unzGoToFirstFile (unzFile file)
   return UNZ_OK if there is no problem
   return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
 */
-extern int ZEXPORT unzGoToNextFile (unzFile file)
+extern int ZEXPORT unzGoToNextFile (file)
+    unzFile file;
 {
     unz_s* s;
     int err;
@@ -791,7 +826,10 @@ extern int ZEXPORT unzGoToNextFile (unzFile file)
   UNZ_OK if the file is found. It becomes the current file.
   UNZ_END_OF_LIST_OF_FILE if the file is not found
 */
-extern int ZEXPORT unzLocateFile (unzFile file, const char *szFileName, int iCaseSensitivity)
+extern int ZEXPORT unzLocateFile (file, szFileName, iCaseSensitivity)
+    unzFile file;
+    const char *szFileName;
+    int iCaseSensitivity;
 {
     unz_s* s;
     int err;
@@ -867,7 +905,9 @@ typedef struct unz_file_pos_s
 } unz_file_pos;
 */
 
-extern int ZEXPORT unzGetFilePos(unzFile file, unz_file_pos* file_pos)
+extern int ZEXPORT unzGetFilePos(file, file_pos)
+    unzFile file;
+    unz_file_pos* file_pos;
 {
     unz_s* s;
 
@@ -883,7 +923,9 @@ extern int ZEXPORT unzGetFilePos(unzFile file, unz_file_pos* file_pos)
     return UNZ_OK;
 }
 
-extern int ZEXPORT unzGoToFilePos(unzFile file, unz_file_pos*file_pos)
+extern int ZEXPORT unzGoToFilePos(file, file_pos)
+    unzFile file;
+    unz_file_pos* file_pos;
 {
     unz_s* s;
     int err;
@@ -917,11 +959,13 @@ extern int ZEXPORT unzGoToFilePos(unzFile file, unz_file_pos*file_pos)
   store in *piSizeVar the size of extra info in local header
         (filename and size of extra field data)
 */
-local int unzlocal_CheckCurrentFileCoherencyHeader (
+local int unzlocal_CheckCurrentFileCoherencyHeader (s,piSizeVar,
-    unz_s* s,
+                                                    poffset_local_extrafield,
-    uInt* piSizeVar,
+                                                    psize_local_extrafield)
-    uLong *poffset_local_extrafield,
+    unz_s* s;
-    uInt  *psize_local_extrafield)
+    uInt* piSizeVar;
+    uLong *poffset_local_extrafield;
+    uInt  *psize_local_extrafield;
 {
     uLong uMagic,uData,uFlags;
     uLong size_filename;
@@ -1006,12 +1050,12 @@ local int unzlocal_CheckCurrentFileCoherencyHeader (
   Open for reading data the current file in the zipfile.
   If there is no error and the file is opened, the return value is UNZ_OK.
 */
-extern int ZEXPORT unzOpenCurrentFile3 (
+extern int ZEXPORT unzOpenCurrentFile3 (file, method, level, raw, password)
-    unzFile file,
+    unzFile file;
-    int* method,
+    int* method;
-    int* level,
+    int* level;
-    int raw,
+    int raw;
-    const char* password)
+    const char* password;
 {
     int err=UNZ_OK;
     uInt iSizeVar;
@@ -1092,7 +1136,7 @@ extern int ZEXPORT unzOpenCurrentFile3 (
       pfile_in_zip_read_info->stream.zalloc = (alloc_func)0;
       pfile_in_zip_read_info->stream.zfree = (free_func)0;
       pfile_in_zip_read_info->stream.opaque = (voidpf)0;
-      pfile_in_zip_read_info->stream.next_in = (Bytef*)0;
+      pfile_in_zip_read_info->stream.next_in = (voidpf)0;
       pfile_in_zip_read_info->stream.avail_in = 0;
 
       err=inflateInit2(&pfile_in_zip_read_info->stream, -MAX_WBITS);
@@ -1151,21 +1195,24 @@ extern int ZEXPORT unzOpenCurrentFile3 (
     return UNZ_OK;
 }
 
-extern int ZEXPORT unzOpenCurrentFile (unzFile file)
+extern int ZEXPORT unzOpenCurrentFile (file)
+    unzFile file;
 {
     return unzOpenCurrentFile3(file, NULL, NULL, 0, NULL);
 }
 
-extern int ZEXPORT unzOpenCurrentFilePassword (unzFile file, const char* password)
+extern int ZEXPORT unzOpenCurrentFilePassword (file, password)
+    unzFile file;
+    const char* password;
 {
     return unzOpenCurrentFile3(file, NULL, NULL, 0, password);
 }
 
-extern int ZEXPORT unzOpenCurrentFile2 (
+extern int ZEXPORT unzOpenCurrentFile2 (file,method,level,raw)
-    unzFile file,
+    unzFile file;
-    int* method,
+    int* method;
-    int* level,
+    int* level;
-    int raw)
+    int raw;
 {
     return unzOpenCurrentFile3(file, method, level, raw, NULL);
 }
@@ -1180,10 +1227,10 @@ extern int ZEXPORT unzOpenCurrentFile2 (
   return <0 with error code if there is an error
     (UNZ_ERRNO for IO error, or zLib error for uncompress error)
 */
-extern int ZEXPORT unzReadCurrentFile(
+extern int ZEXPORT unzReadCurrentFile  (file, buf, len)
-    unzFile file,
+    unzFile file;
-    voidp buf,
+    voidp buf;
-    unsigned len)
+    unsigned len;
 {
     int err=UNZ_OK;
     uInt iRead = 0;
@@ -1341,7 +1388,8 @@ extern int ZEXPORT unzReadCurrentFile(
 /*
   Give the current position in uncompressed data
 */
-extern z_off_t ZEXPORT unztell (unzFile file)
+extern z_off_t ZEXPORT unztell (file)
+    unzFile file;
 {
     unz_s* s;
     file_in_zip_read_info_s* pfile_in_zip_read_info;
@@ -1360,7 +1408,8 @@ extern z_off_t ZEXPORT unztell (unzFile file)
 /*
   return 1 if the end of file was reached, 0 elsewhere
 */
-extern int ZEXPORT unzeof (unzFile file)
+extern int ZEXPORT unzeof (file)
+    unzFile file;
 {
     unz_s* s;
     file_in_zip_read_info_s* pfile_in_zip_read_info;
@@ -1392,10 +1441,10 @@ extern int ZEXPORT unzeof (unzFile file)
   the return value is the number of bytes copied in buf, or (if <0)
     the error code
 */
-extern int ZEXPORT unzGetLocalExtrafield (
+extern int ZEXPORT unzGetLocalExtrafield (file,buf,len)
-    unzFile file,
+    unzFile file;
-    voidp buf,
+    voidp buf;
-    unsigned len)
+    unsigned len;
 {
     unz_s* s;
     file_in_zip_read_info_s* pfile_in_zip_read_info;
@@ -1443,7 +1492,8 @@ extern int ZEXPORT unzGetLocalExtrafield (
   Close the file in zip opened with unzipOpenCurrentFile
   Return UNZ_CRCERROR if all the file was read but the CRC is not good
 */
-extern int ZEXPORT unzCloseCurrentFile (unzFile file)
+extern int ZEXPORT unzCloseCurrentFile (file)
+    unzFile file;
 {
     int err=UNZ_OK;
 
@@ -1485,11 +1535,12 @@ extern int ZEXPORT unzCloseCurrentFile (unzFile file)
   uSizeBuf is the size of the szComment buffer.
   return the number of byte copied or an error code <0
 */
-extern int ZEXPORT unzGetGlobalComment (
+extern int ZEXPORT unzGetGlobalComment (file, szComment, uSizeBuf)
-    unzFile file,
+    unzFile file;
-    char *szComment,
+    char *szComment;
-    uLong uSizeBuf)
+    uLong uSizeBuf;
 {
+    int err=UNZ_OK;
     unz_s* s;
     uLong uReadThis ;
     if (file==NULL)
@@ -1516,7 +1567,8 @@ extern int ZEXPORT unzGetGlobalComment (
 }
 
 /* Additions by RX '2004 */
-extern uLong ZEXPORT unzGetOffset (unzFile file)
+extern uLong ZEXPORT unzGetOffset (file)
+    unzFile file;
 {
     unz_s* s;
 
@@ -1531,9 +1583,9 @@ extern uLong ZEXPORT unzGetOffset (unzFile file)
     return s->pos_in_central_dir;
 }
 
-extern int ZEXPORT unzSetOffset (
+extern int ZEXPORT unzSetOffset (file, pos)
-        unzFile file,
+        unzFile file;
-        uLong pos)
+        uLong pos;
 {
     unz_s* s;
     int err;

JGE/src/unzip/zip.c

@@ -172,7 +172,8 @@ local linkedlist_datablock_internal* allocate_new_datablock()
     return ldi;
 }
 
-local void free_datablock(linkedlist_datablock_internal* ldi)
+local void free_datablock(ldi)
+    linkedlist_datablock_internal* ldi;
 {
     while (ldi!=NULL)
     {
@@ -182,24 +183,24 @@ local void free_datablock(linkedlist_datablock_internal* ldi)
     }
 }
 
-local void init_linkedlist(
+local void init_linkedlist(ll)
-    linkedlist_data* ll)
+    linkedlist_data* ll;
 {
     ll->first_block = ll->last_block = NULL;
 }
 
-local void free_linkedlist(
+local void free_linkedlist(ll)
-    linkedlist_data* ll)
+    linkedlist_data* ll;
 {
     free_datablock(ll->first_block);
     ll->first_block = ll->last_block = NULL;
 }
 
 
-local int add_data_in_datablock(
+local int add_data_in_datablock(ll,buf,len)
-    linkedlist_data* ll,
+    linkedlist_data* ll;
-    const void* buf,
+    const void* buf;
-    uLong len)
+    uLong len;
 {
     linkedlist_datablock_internal* ldi;
     const unsigned char* from_copy;
@@ -262,11 +263,11 @@ local int add_data_in_datablock(
 
 local int ziplocal_putValue OF((const zlib_filefunc_def* pzlib_filefunc_def,
                                 voidpf filestream, uLong x, int nbByte));
-local int ziplocal_putValue (
+local int ziplocal_putValue (pzlib_filefunc_def, filestream, x, nbByte)
-    const zlib_filefunc_def* pzlib_filefunc_def,
+    const zlib_filefunc_def* pzlib_filefunc_def;
-    voidpf filestream,
+    voidpf filestream;
-    uLong x,
+    uLong x;
-    int nbByte)
+    int nbByte;
 {
     unsigned char buf[4];
     int n;
@@ -290,10 +291,10 @@ local int ziplocal_putValue (
 }
 
 local void ziplocal_putValue_inmemory OF((void* dest, uLong x, int nbByte));
-local void ziplocal_putValue_inmemory (
+local void ziplocal_putValue_inmemory (dest, x, nbByte)
-    void* dest,
+    void* dest;
-    uLong x,
+    uLong x;
-    int nbByte)
+    int nbByte;
 {
     unsigned char* buf=(unsigned char*)dest;
     int n;
@@ -314,9 +315,9 @@ local void ziplocal_putValue_inmemory (
 /****************************************************************************/
 
 
-local uLong ziplocal_TmzDateToDosDate(
+local uLong ziplocal_TmzDateToDosDate(ptm,dosDate)
-    const tm_zip* ptm,
+    const tm_zip* ptm;
-    uLong dosDate)
+    uLong dosDate;
 {
     uLong year = (uLong)ptm->tm_year;
     if (year>1980)
@@ -336,10 +337,10 @@ local int ziplocal_getByte OF((
     voidpf filestream,
     int *pi));
 
-local int ziplocal_getByte(
+local int ziplocal_getByte(pzlib_filefunc_def,filestream,pi)
-    const zlib_filefunc_def* pzlib_filefunc_def,
+    const zlib_filefunc_def* pzlib_filefunc_def;
-    voidpf filestream,
+    voidpf filestream;
-    int *pi)
+    int *pi;
 {
     unsigned char c;
     int err = (int)ZREAD(*pzlib_filefunc_def,filestream,&c,1);
@@ -366,10 +367,10 @@ local int ziplocal_getShort OF((
     voidpf filestream,
     uLong *pX));
 
-local int ziplocal_getShort (
+local int ziplocal_getShort (pzlib_filefunc_def,filestream,pX)
-    const zlib_filefunc_def* pzlib_filefunc_def,
+    const zlib_filefunc_def* pzlib_filefunc_def;
-    voidpf filestream,
+    voidpf filestream;
-    uLong *pX)
+    uLong *pX;
 {
     uLong x ;
     int i;
@@ -394,10 +395,10 @@ local int ziplocal_getLong OF((
     voidpf filestream,
     uLong *pX));
 
-local int ziplocal_getLong (
+local int ziplocal_getLong (pzlib_filefunc_def,filestream,pX)
-    const zlib_filefunc_def* pzlib_filefunc_def,
+    const zlib_filefunc_def* pzlib_filefunc_def;
-    voidpf filestream,
+    voidpf filestream;
-    uLong *pX)
+    uLong *pX;
 {
     uLong x ;
     int i;
@@ -436,9 +437,9 @@ local uLong ziplocal_SearchCentralDir OF((
     const zlib_filefunc_def* pzlib_filefunc_def,
     voidpf filestream));
 
-local uLong ziplocal_SearchCentralDir(
+local uLong ziplocal_SearchCentralDir(pzlib_filefunc_def,filestream)
-    const zlib_filefunc_def* pzlib_filefunc_def,
+    const zlib_filefunc_def* pzlib_filefunc_def;
-    voidpf filestream)
+    voidpf filestream;
 {
     unsigned char* buf;
     uLong uSizeFile;
@@ -495,11 +496,11 @@ local uLong ziplocal_SearchCentralDir(
 #endif /* !NO_ADDFILEINEXISTINGZIP*/
 
 /************************************************************/
-extern zipFile ZEXPORT zipOpen2 (
+extern zipFile ZEXPORT zipOpen2 (pathname, append, globalcomment, pzlib_filefunc_def)
-    const char *pathname,
+    const char *pathname;
-    int append,
+    int append;
-    zipcharpc* globalcomment,
+    zipcharpc* globalcomment;
-    zlib_filefunc_def* pzlib_filefunc_def)
+    zlib_filefunc_def* pzlib_filefunc_def;
 {
     zip_internal ziinit;
     zip_internal* zi;
@@ -614,7 +615,7 @@ extern zipFile ZEXPORT zipOpen2 (
 
         if (size_comment>0)
         {
-            ziinit.globalcomment = (char*)ALLOC(size_comment+1);
+            ziinit.globalcomment = ALLOC(size_comment+1);
             if (ziinit.globalcomment)
             {
                size_comment = ZREAD(ziinit.z_filefunc, ziinit.filestream,ziinit.globalcomment,size_comment);
@@ -679,30 +680,35 @@ extern zipFile ZEXPORT zipOpen2 (
     }
 }
 
-extern zipFile ZEXPORT zipOpen (
+extern zipFile ZEXPORT zipOpen (pathname, append)
-    const char *pathname,
+    const char *pathname;
-    int append)
+    int append;
 {
     return zipOpen2(pathname,append,NULL,NULL);
 }
 
-extern int ZEXPORT zipOpenNewFileInZip3 (
+extern int ZEXPORT zipOpenNewFileInZip3 (file, filename, zipfi,
-    zipFile file,
+                                         extrafield_local, size_extrafield_local,
-    const char* filename,
+                                         extrafield_global, size_extrafield_global,
-    const zip_fileinfo* zipfi,
+                                         comment, method, level, raw,
-    const void* extrafield_local,
+                                         windowBits, memLevel, strategy,
-    uInt size_extrafield_local,
+                                         password, crcForCrypting)
-    const void* extrafield_global,
+    zipFile file;
-    uInt size_extrafield_global,
+    const char* filename;
-    const char* comment,
+    const zip_fileinfo* zipfi;
-    int method,
+    const void* extrafield_local;
-    int level,
+    uInt size_extrafield_local;
-    int raw,
+    const void* extrafield_global;
-    int windowBits,
+    uInt size_extrafield_global;
-    int memLevel,
+    const char* comment;
-    int strategy,
+    int method;
-    const char* password,
+    int level;
-    uLong crcForCrypting)
+    int raw;
+    int windowBits;
+    int memLevel;
+    int strategy;
+    const char* password;
+    uLong crcForCrypting;
 {
     zip_internal* zi;
     uInt size_filename;
@@ -890,18 +896,21 @@ extern int ZEXPORT zipOpenNewFileInZip3 (
     return err;
 }
 
-extern int ZEXPORT zipOpenNewFileInZip2(
+extern int ZEXPORT zipOpenNewFileInZip2(file, filename, zipfi,
-    zipFile file,
+                                        extrafield_local, size_extrafield_local,
-    const char* filename,
+                                        extrafield_global, size_extrafield_global,
-    const zip_fileinfo* zipfi,
+                                        comment, method, level, raw)
-    const void* extrafield_local,
+    zipFile file;
-    uInt size_extrafield_local,
+    const char* filename;
-    const void* extrafield_global,
+    const zip_fileinfo* zipfi;
-    uInt size_extrafield_global,
+    const void* extrafield_local;
-    const char* comment,
+    uInt size_extrafield_local;
-    int method,
+    const void* extrafield_global;
-    int level,
+    uInt size_extrafield_global;
-    int raw)
+    const char* comment;
+    int method;
+    int level;
+    int raw;
 {
     return zipOpenNewFileInZip3 (file, filename, zipfi,
                                  extrafield_local, size_extrafield_local,
@@ -911,17 +920,20 @@ extern int ZEXPORT zipOpenNewFileInZip2(
                                  NULL, 0);
 }
 
-extern int ZEXPORT zipOpenNewFileInZip (
+extern int ZEXPORT zipOpenNewFileInZip (file, filename, zipfi,
-    zipFile file,
+                                        extrafield_local, size_extrafield_local,
-    const char* filename,
+                                        extrafield_global, size_extrafield_global,
-    const zip_fileinfo* zipfi,
+                                        comment, method, level)
-    const void* extrafield_local,
+    zipFile file;
-    uInt size_extrafield_local,
+    const char* filename;
-    const void* extrafield_global,
+    const zip_fileinfo* zipfi;
-    uInt size_extrafield_global,
+    const void* extrafield_local;
-    const char* comment,
+    uInt size_extrafield_local;
-    int method,
+    const void* extrafield_global;
-    int level)
+    uInt size_extrafield_global;
+    const char* comment;
+    int method;
+    int level;
 {
     return zipOpenNewFileInZip2 (file, filename, zipfi,
                                  extrafield_local, size_extrafield_local,
@@ -929,8 +941,8 @@ extern int ZEXPORT zipOpenNewFileInZip (
                                  comment, method, level, 0);
 }
 
-local int zipFlushWriteBuffer(
+local int zipFlushWriteBuffer(zi)
-  zip_internal* zi)
+  zip_internal* zi;
 {
     int err=ZIP_OK;
 
@@ -951,10 +963,10 @@ local int zipFlushWriteBuffer(
     return err;
 }
 
-extern int ZEXPORT zipWriteInFileInZip (
+extern int ZEXPORT zipWriteInFileInZip (file, buf, len)
-    zipFile file,
+    zipFile file;
-    const void* buf,
+    const void* buf;
-    unsigned len)
+    unsigned len;
 {
     zip_internal* zi;
     int err=ZIP_OK;
@@ -966,9 +978,9 @@ extern int ZEXPORT zipWriteInFileInZip (
     if (zi->in_opened_file_inzip == 0)
         return ZIP_PARAMERROR;
 
-    zi->ci.stream.next_in = (Bytef*)buf;
+    zi->ci.stream.next_in = (void*)buf;
     zi->ci.stream.avail_in = len;
-    zi->ci.crc32 = crc32(zi->ci.crc32,(const Bytef*)buf,len);
+    zi->ci.crc32 = crc32(zi->ci.crc32,buf,len);
 
     while ((err==ZIP_OK) && (zi->ci.stream.avail_in>0))
     {
@@ -1016,10 +1028,10 @@ extern int ZEXPORT zipWriteInFileInZip (
     return err;
 }
 
-extern int ZEXPORT zipCloseFileInZipRaw (
+extern int ZEXPORT zipCloseFileInZipRaw (file, uncompressed_size, crc32)
-    zipFile file,
+    zipFile file;
-    uLong uncompressed_size,
+    uLong uncompressed_size;
-    uLong crc32)
+    uLong crc32;
 {
     zip_internal* zi;
     uLong compressed_size;
@@ -1112,15 +1124,15 @@ extern int ZEXPORT zipCloseFileInZipRaw (
     return err;
 }
 
-extern int ZEXPORT zipCloseFileInZip (
+extern int ZEXPORT zipCloseFileInZip (file)
-    zipFile file)
+    zipFile file;
 {
     return zipCloseFileInZipRaw (file,0,0);
 }
 
-extern int ZEXPORT zipClose (
+extern int ZEXPORT zipClose (file, global_comment)
-    zipFile file,
+    zipFile file;
-    const char* global_comment)
+    const char* global_comment;
 {
     zip_internal* zi;
     int err = 0;

JGE/src/zipFS/zfsystem.cpp

@@ -42,6 +42,7 @@ filesystem * filesystem::pCurrentFS = NULL;
 std::vector<filesystem::pooledBuffer *> filesystem::m_Buffers;
 
 static const int STORED = 0;
+static const int DEFLATED = 8;
 
 //////////////////////////////////////////////////////////////////////
 // Construction/Destruction
@@ -631,8 +632,8 @@ streamoff filesystem::CentralDirZipped(std::istream & File, std::streamoff begin
     std::streamoff eof = begin + size;
 
 	// Look for the "end of central dir" header. Start minimum 22 bytes before end.
-	if (! File.seekg(eof - 22, ios::beg))
+    if (! File.seekg(eof - 22, ios::beg))
-		return -1;
+        return -1;
 
 	streamoff EndPos;
 	streamoff StartPos = File.tellg();

JGE/src/zipFS/zfsystem.h

@@ -258,8 +258,8 @@ inline void izfstream::open(const char * FilePath, filesystem * pFS) {
     if (pFS)
         m_pFS = pFS;
 
-    if (m_pFS != NULL)
+	if (m_pFS != NULL)
-        m_pFS->Open(* this, FilePath);
+		m_pFS->Open(* this, FilePath);
 }
 
 inline void izfstream::close() {

JGE/src/zipFS/zstream.cpp

@@ -76,8 +76,8 @@ bool zbuffer::use(std::streamoff Offset, std::streamoff Size)
 		return false;
 
     //Don't use a buffer already used;
-	if (m_Used)
+    if (m_Used)
-		return false;
+        return false;
 
 	// adjust file position
 	if (! m_ZipFile.seekg(Offset, ios::beg))

JGE/src/zipFS/zstream.h

@@ -106,7 +106,6 @@ public:
  	virtual int overflow(int c = EOF);
 	virtual int underflow();
 	virtual int	sync();
-    using std::streambuf::setbuf;
 	virtual std::streambuf * setbuf(char * pr, int nLength);
 	virtual std::streampos seekoff(std::streamoff, std::ios::seekdir, std::ios::openmode);
 
@@ -132,7 +131,6 @@ public:
  	virtual int overflow(int c = EOF);
 	virtual int underflow();
 	virtual int sync();
-    using std::streambuf::setbuf;
 	virtual std::streambuf * setbuf(char * pr, int nLength);
 	virtual std::streampos seekoff(std::streamoff, std::ios::seekdir, std::ios::openmode);
 

README.md

@@ -1,45 +1,21 @@
-# Wagic the Homebrew
+#Wagic the Homebrew
 
-[![Build Status](https://travis-ci.org/WagicProject/wagic.png?branch=master)](https://travis-ci.com/WagicProject/wagic)
+
-[![Build status](https://ci.appveyor.com/api/projects/status/7j4fbr6m62aqej59/branch/master)](https://ci.appveyor.com/project/xawotihs/wagic/branch/master)
+[![Build Status](https://travis-ci.org/WagicProject/wagic.png?branch=master)](https://travis-ci.org/WagicProject/wagic)
-[![Coverage Status](https://coveralls.io/repos/WagicProject/wagic/badge.png?branch=master)](https://coveralls.io/r/WagicProject/wagic?branch=master)
 
 ## Description
 
-**Wagic, the Homebrew** is a C++ game engine that allows to play card games against an AI on:
+Wagic, the Homebrew, is a C++ game engine that allows to play card games against an AI on
 - Android (phones and tablets) 
 - iOS (iPhone/iPad)
 - Sony PSP
 - Windows desktops 
 - MacOS
-- Linux and derivatives like Maemo or Meego 
+- Linux and derivated like Maemo or Meego 
 
-It is highly customizable and allows the player to tweak the rules, create their own cards, their own themes, etc... 
+It is highly customizable and allows the player to tweak the rules / create their own cards, their own themes, etc... 
-
-#### [Download from GitHub Releases!](https://github.com/WagicProject/wagic/releases)
-
-![Screenshot of shop from wololo.net](docs/img/shop.jpg)
 
 
-### Documentation
+Info, Downloads, and more at http://wololo.net
 
-Info, downloads, discussions and more at http://wololo.net/forum/index.php (archived as of 16 Nov 2022).
+-![alt text](http://wololo.net/wagic/wp-content/uploads/2009/10/shop.jpg "Screenshot")
-
-Chat with the community on the [**Wagic - MTG Game** Discord](https://discord.com/invite/JHK5pVaK5p) (Feb 2023).
-
-Developer information from the [Wagic Wiki](https://github.com/WagicProject/wagic/wiki) is also included in the [wagic/docs/](docs) folder.
-
-
-### Sample round play-through video
-
-[![Wagic, The Homebrew sample playthrough](docs/img/Wagic%2C%20The%20Homebrew%20sample%20playthrough.jpg)](http://www.youtube.com/watch?v=WUFSAPZuDIk)
-
-*Wagic, The Homebrew sample playthrough on YouTube by Rolz73, 6 Feb 2014*
-
-
-## Sister projects
-
-- [WagicSyntaxPlugin
-](https://github.com/Vitty85/WagicSyntaxPlugin), a Wagic developer tool by Vitty85 for [Notepad++](https://notepad-plus-plus.org/downloads/)
-- [Forge](https://www.slightlymagic.net/forum/viewforum.php?f=26), a Java-based game engine similar to Wagic ([Source](https://github.com/Card-Forge/forge/))
-- [XMage](http://xmage.today/), a Java-based online multiplayer digital CCG ([Source](https://github.com/magefree/mage))

appveyor.yml

@@ -1,76 +0,0 @@
-# Notes:
-#   - Minimal appveyor.yml file is an empty file. All sections are optional.
-#   - Indent each level of configuration with 2 spaces. Do not use tabs!
-#   - All section names are case-sensitive.
-#   - Section names should be unique on each level.
-
-# branches to build
-branches:
-  # blacklist
-  except:
-    - travis_mac_osx
-# Do not build on tags (GitHub only)
-skip_tags: true
-
-#---------------------------------#
-#    environment configuration    #
-#---------------------------------#
-
-environment:
-  GH_TOKEN:
-    secure: dYnBDQkiY5oVjIlswzBX9BJigNtBGXgGlp1tK3XbHzrDEDrs2vaKD5m+Oz5OSz1C
-
-# scripts that run after cloning repository
-install:
-  - powershell -Command "& {(new-object net.webclient).DownloadFile('https://bootstrap.pypa.io/get-pip.py', 'C:/get-pip.py')}"
-  - powershell -Command "& {C:/Python27/python.exe C:/get-pip.py}"
-  - "C:/Python27/Scripts/pip.exe install pyjavaproperties"
-  - "C:/Python27/Scripts/pip.exe install github3.py"
-
-#---------------------------------#
-#       build configuration       #
-#---------------------------------#
-
-# build Configuration, i.e. Debug, Release, etc.
-configuration: Release
-
-build:
-  project: projects/mtg/mtg_vs2010.sln      # path to Visual Studio solution or project
-
-#---------------------------------#
-#       tests configuration       #
-#---------------------------------#
-
-# to disable automatic tests
-test: off
-
-
-#---------------------------------#
-#      artifacts configuration    #
-#---------------------------------#
-
-artifacts:
-  # pushing windows package
-  - path: projects\mtg\bin\Wagic-windows*.zip
-
-
-#---------------------------------#
-#     deployment configuration    #
-#---------------------------------#
-
-# scripts to run before deployment
-before_deploy:
-  - cd projects/mtg/bin
-  - "C:/Python27/python.exe createWindowsZip.py"
-  - cd ../../..
-
-# scripts to run after deployment
-after_deploy:
-
-# to run your custom scripts instead of provider deployments
-deploy_script:
-  - "C:/Python27/python.exe tools/upload-binaries.py -t %GH_TOKEN% -s %APPVEYOR_REPO_COMMIT% -l projects/mtg/bin/Wagic-windows.zip -r Wagic-windows.zip -b %APPVEYOR_REPO_BRANCH%"
-
-# to disable deployment
-#deploy: off
-

projects/mtg/Android/.gitignore

@@ -1,4 +1,3 @@
 /gen
 /bin
-/libs
 

projects/mtg/Android/AndroidManifest.xml

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

projects/mtg/Android/default.properties

@@ -8,4 +8,4 @@
 # project structure.
 
 # Project target.
-target=android-23
+target=android-10

projects/mtg/Android/jni/Android.mk

@@ -11,9 +11,10 @@ SDL_PATH := $(JGE_PATH)/Dependencies/SDL
 BOOST_PATH := $(MY_WAGIC_ROOT)/Boost
 JPEG_PATH := $(JGE_PATH)/Dependencies/libjpeg
 PNG_PATH := $(JGE_PATH)/Dependencies/libpng
+DEBUG ?= DEBUG
 
-LOCAL_CFLAGS += -DLINUX -DANDROID -DSDL_CONFIG -DNETWORK_SUPPORT
+LOCAL_CFLAGS += -DLINUX -DANDROID -DSDL_CONFIG -D_$(DEBUG)
-LOCAL_CFLAGS += -D_STLP_USE_SIMPLE_NODE_ALLOC -DTIXML_USE_STL
+LOCAL_CFLAGS += -D_STLP_USE_SIMPLE_NODE_ALLOC
 LOCAL_CFLAGS += -D__arm__ -D_REENTRANT -D_GLIBCXX__PTHREADS
 LOCAL_STATIC_LIBRARIES := libpng libjpeg
 LOCAL_SHARED_LIBRARIES := SDL
@@ -56,6 +57,7 @@ LOCAL_SRC_FILES := $(SDL_PATH)/src/main/android/SDL_android_main.cpp \
         $(MTG_PATH)/src/DeckMetaData.cpp \
         $(MTG_PATH)/src/DeckStats.cpp \
         $(MTG_PATH)/src/DuelLayers.cpp \
+        $(MTG_PATH)/src/Effects.cpp \
         $(MTG_PATH)/src/ExtraCost.cpp \
         $(MTG_PATH)/src/GameApp.cpp \
         $(MTG_PATH)/src/GameLauncher.cpp \
@@ -133,11 +135,7 @@ LOCAL_SRC_FILES := $(SDL_PATH)/src/main/android/SDL_android_main.cpp \
         $(MTG_PATH)/src/WFilter.cpp \
         $(MTG_PATH)/src/WFont.cpp \
         $(MTG_PATH)/src/WGui.cpp \
-        $(MTG_PATH)/src/WParsedInt.cpp \
         $(MTG_PATH)/src/WResourceManager.cpp \
-        $(MTG_PATH)/src/DeckView.cpp \
-        $(MTG_PATH)/src/CarouselDeckView.cpp \
-        $(MTG_PATH)/src/GridDeckView.cpp \
         $(JGE_PATH)/src/SDLmain.cpp \
         $(JGE_PATH)/src/Encoding.cpp \
         $(JGE_PATH)/src/JAnimator.cpp \

projects/mtg/Android/jni/Application.mk

@@ -1,11 +1,7 @@
 APP_PROJECT_PATH := $(call my-dir)/..
 APP_CPPFLAGS += -frtti -fexceptions
-APP_ABI := arm64-v8a
+APP_ABI := armeabi armeabi-v7a
-APP_PLATFORM := android-21
+APP_STL := gnustl_static
-APP_CFLAGS += -march=armv8.1-a
-APP_CPPFLAGS += -D__ARM_FEATURE_LSE=1
-#APP_ABI := x86 # mainly for emulators
-APP_STL := c++_static
 APP_MODULES := libpng libjpeg main SDL
 
 #APP_OPTIM is 'release' by default

projects/mtg/Android/project.properties

@@ -11,4 +11,4 @@
 #proguard.config=${sdk.dir}/tools/proguard/proguard-android.txt:proguard-project.txt
 
 # Project target.
-target=android-23
+target=android-10

projects/mtg/Android/res/layout/main.xml

@@ -4,7 +4,6 @@
     android:id="@+id/mainLayout"
     android:layout_width="fill_parent"
     android:layout_height="fill_parent"
-    android:keepScreenOn="true"
     >
 <TextView  
     android:layout_width="fill_parent" 

projects/mtg/Android/res/values/strings.xml

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

projects/mtg/Android/src/net/wagic/utils/DeckImporter.java

@@ -1,279 +0,0 @@
-package net.wagic.utils;
-
-import java.io.FileOutputStream;
-import java.io.FileReader;
-import java.io.FileWriter;
-import java.io.File;
-import java.io.IOException;
-import java.util.Scanner;
-
-import android.util.Log;
-
-public class DeckImporter
-{
-    public static String importDeck( File f, String mypath, String activePath )
-    {
-        String message = "";
-        String deck = "";
-        String deckname = "";
-        String prefix = "";
-        int cardcount = 0;
-        if(f.exists() && !f.isDirectory())
-        { 
-            deckname = f.getName();
-            int pos = deckname.lastIndexOf(".");
-            if (pos > 0) 
-            {
-                deckname = deckname.substring(0, pos);
-            }
-            deck += "#NAME:"+deckname+"\n"; 
-            try
-            {
-                Scanner scanner = new Scanner(new File(mypath));                
-                if (scanner.hasNext()) 
-                {
-                    while (scanner.hasNext()) 
-                    {
-                        String line = scanner.nextLine();
-                        line = line.trim();
-                        if (line.equals("")) {
-                            line = scanner.nextLine();
-                            prefix = "#SB:"; // Sideboard started from next card.
-                            if (line.equals("")) {
-                                line = scanner.nextLine(); // Sometimes there are 2 blank lines from main deck and sideboard.
-                            }
-                        }
-                        if (!line.equals("")) // don't write out blank lines
-                        {
-                            String[] slines = line.split("\\s+");
-                            String arranged = "";
-                            for (int idx = 1; idx < slines.length; idx++)
-                            {
-                                arranged += slines[idx] + " ";
-                            }
-                            if ((isNumeric(slines[0])) && arranged != null)
-                            {
-                                if (slines[1] != null && slines[1].startsWith("["))
-                                {
-                                    arranged = arranged.substring(5);
-                                    slines[1] = slines[1].replaceAll("\\[", "").replaceAll("\\]", "");
-                                    deck += prefix + arranged + " (" + renameSet(slines[1]) + ") * " + slines[0] + "\n";
-                                } else
-                                {
-                                    deck += prefix + arranged + "(*) * " + slines[0] + "\n";
-                                }
-                                cardcount += Integer.parseInt(slines[0]);
-                            }
-                        }
-                    }
-                    File profile = new File(activePath + "/User/settings/options.txt");
-                    String profileName = "Default";
-                    if (profile.exists() && !profile.isDirectory())
-                        profileName = getActiveProfile(profile);
-                    File rootDecks = null;
-                    if (!profileName.equalsIgnoreCase("Default"))
-                        rootDecks = new File(activePath + "/User/profiles/" + profileName);
-                    else
-                        rootDecks = new File(activePath + "/User/player/");
-                    if (rootDecks.exists() && rootDecks.isDirectory())
-                    {
-                        //save deck
-                        int countdeck = 1;
-                        File[] files = rootDecks.listFiles();
-                        for (int i = 0; i < files.length; i++)
-                        {//check if there is available deck...
-                            if (files[i].getName().startsWith("deck"))
-                                countdeck++;
-                        }
-                        File toSave = new File(rootDecks + "/deck" + countdeck + ".txt");
-                        try
-                        {
-                            FileOutputStream fop = new FileOutputStream(toSave);
-
-                            // if file doesn't exists, then create it
-                            if (!toSave.exists())
-                            {
-                                toSave.createNewFile();
-                            }
-                            // get the content in bytes
-                            byte[] contentInBytes = deck.getBytes();
-                            fop.write(contentInBytes);
-                            fop.flush();
-                            fop.close();
-                            message = "The deck has been successfully imported as: " + toSave.getName() + "\n" + cardcount + " total cards in this deck\n\n" + deck;
-                        } catch (IOException e)
-                        {
-                            message = e.getMessage();
-                        }
-                    } else
-                    {
-                        message = "Problem opening decks folder: " + rootDecks.getAbsolutePath();
-                    }
-                } else
-                {
-                    message = "No errors, and file EMPTY";
-                }
-            } catch (IOException e)
-            {
-                message = e.getMessage();
-            }
-        }
-        return message;
-    }
-      
-    private static boolean isNumeric(String input)
-    {
-        try
-        {
-            Integer.parseInt(input);
-        }
-        catch(NumberFormatException ex)
-        {
-            return false;
-        }
-        return true;
-    }
-
-    private static String getActiveProfile(File mypath)
-    {
-        String name = "";
-        try
-            {
-                Scanner scanner = new Scanner(new File(mypath.toString()));                
-                if (scanner.hasNext()) 
-                {
-                    String line = scanner.nextLine();
-                    name = line.substring(8);    
-                }
-                else
-                {
-                    return "Default";
-                }
-            }
-            catch(IOException e)
-            {
-                return "Default";
-            }
-        return name;
-    }
-
-    private static String renameSet(String set)
-    {
-        if (set == "")
-            return "*";
-        if (set == "AL")
-            return "ALL";
-        if (set == "AQ")
-            return "ATQ";
-        if (set == "AP")
-            return "APC";
-        if (set == "AN")
-            return "ARN";
-        if (set == "AE")
-            return "ARC";
-        if (set == "BR")
-            return "BRB";
-        if (set == "BD")
-            return "BTD";
-        if (set == "CH")
-            return "CHR";
-        if (set == "6E")
-            return "6ED";
-        if (set == "CS")
-            return "CSP";
-        if (set == "DS")
-            return "DST";
-        if (set == "D2")
-            return "DD2";
-        if (set == "8E")
-            return "8ED";
-        if (set == "EX")
-            return "EXO";
-        if (set == "FE")
-            return "FEM";
-        if (set == "FD")
-            return "5DN";
-        if (set == "5E")
-            return "5ED";
-        if (set == "4E")
-            return "4ED";
-        if (set == "GP")
-            return "GPT";
-        if (set == "HL")
-            return "HML";
-        if (set == "IA")
-            return "ICE";
-        if (set == "IN")
-            return "INV";
-        if (set == "JU")
-            return "JUD";
-        if (set == "LG")
-            return "LEG";
-        if (set == "LE")
-            return "LGN";
-        if (set == "A")
-            return "LEA";
-        if (set == "B")
-            return "LEB";
-        if (set == "MM")
-            return "MMQ";
-        if (set == "MI")
-            return "MIR";
-        if (set == "MR")
-            return "MRD";
-        if (set == "NE")
-            return "NEM";
-        if (set == "9E")
-            return "9ED";
-        if (set == "OD")
-            return "ODY";
-        if (set == "ON")
-            return "ONS";
-        if (set == "PS")
-            return "PLS";
-        if (set == "PT")
-            return "POR";
-        if (set == "P2")
-            return "P02";
-        if (set == "P3")
-            return "PTK";
-        if (set == "PR")
-            return "PPR";
-        if (set == "PY")
-            return "PCY";
-        if (set == "R")
-            return "RV";
-        if (set == "SC")
-            return "SCG";
-        if (set == "7E")
-            return "7ED";
-        if (set == "ST")
-            return "S99";
-        if (set == "ST2K")
-            return "S00";
-        if (set == "SH")
-            return "STH";
-        if (set == "TE")
-            return "TMP";
-        if (set == "DK")
-            return "DRK";
-        if (set == "TO")
-            return "TOR";
-        if (set == "UG")
-            return "UGL";
-        if (set == "U")
-            return "2ED";
-        if (set == "UD")
-            return "UDS";
-        if (set == "UL")
-            return "ULG";
-        if (set == "US")
-            return "USG";
-        if (set == "VI")
-            return "VIS";
-        if (set == "WL")
-            return "WTH";
-        else
-            return set;
-    }
-}

projects/mtg/Android/src/net/wagic/utils/StorageOptions.java

@@ -5,16 +5,11 @@ import java.io.FileNotFoundException;
 import java.util.ArrayList;
 import java.util.Scanner;
 
-import java.util.HashSet;
-import java.util.Set;
-import android.os.Build;
-
 import android.os.Environment;
 import android.util.Log;
 
 public class StorageOptions
 {
-    private static final String      TAG     = StorageOptions.class.getCanonicalName();
     private static ArrayList<String> mMounts = new ArrayList<String>();
     private static ArrayList<String> mVold   = new ArrayList<String>();
 
@@ -23,29 +18,13 @@ public class StorageOptions
     public static int                count   = 0;
     public static String             defaultMountPoint;
 
-    public static void determineStorageOptions(android.content.Context mContext)
+    public static void determineStorageOptions()
     {
         initializeMountPoints();
-        if (findForcemount()){
-            readMountsFileTest();
-        }
         readMountsFile();
         readVoldFile();
-        if (findForcemount()){
-            removeDuplicates(mMounts);
-        }
         compareMountsWithVold();
         testAndCleanMountsList();
-        File[] externalStorageVolumes = mContext.getExternalFilesDirs("");
-        for(int i = 0; i < externalStorageVolumes.length; i++){
-            mMounts.add(externalStorageVolumes[i].getAbsolutePath());
-        }
-        for(int i = 0; i < mMounts.size(); i++){
-            for(int j = 0; j < mMounts.size(); j++){
-                if(i!=j && mMounts.get(i).startsWith(mMounts.get(j)))
-                    mMounts.remove(i);
-            }
-        }
         setProperties();
     }
 
@@ -61,42 +40,6 @@ public class StorageOptions
         }
     }
 
-    private static void readMountsFileTest()
-    {
-        /*
-         * Test mountpoints storage -kevlahnota
-         */
-
-        try
-        {
-            Scanner scanner = new Scanner(new File("/proc/mounts"));
-            while (scanner.hasNext())
-            {
-                String line = scanner.nextLine();
-                if (line.startsWith("/"))
-                {
-                    String[] lineElements = line.split("\\s+");
-                    if ("vfat".equals(lineElements[2]) || "fuse".equals(lineElements[2]) || "sdcardfs".equals(lineElements[2])) 
-                    {
-                        File mountPoint = new File(lineElements[1]);
-                        if (!lineElements[1].equals(defaultMountPoint))
-                            if (mountPoint.isDirectory() && mountPoint.canRead())
-                                mMounts.add(lineElements[1]);
-                    }
-                }
-            }
-        } catch (FileNotFoundException fnfex)
-        {
-            // if proc/mount doesn't exist we just use
-            Log.i(TAG, fnfex.getMessage() + ": assuming " + defaultMountPoint + " is the only mount point");
-            mMounts.add(defaultMountPoint);
-        } catch (Exception e)
-        {
-            Log.e(TAG, e.getMessage() + ": unknown exception while reading mounts file");
-            mMounts.add(defaultMountPoint);
-        }
-    }
-
     private static void readMountsFile()
     {
         /*
@@ -122,11 +65,11 @@ public class StorageOptions
         } catch (FileNotFoundException fnfex)
         {
             // if proc/mount doesn't exist we just use
-            Log.i(TAG, fnfex.getMessage() + ": assuming " + defaultMountPoint + " is the only mount point");
+            Log.i(StorageOptions.class.getCanonicalName(), fnfex.getMessage() + ": assuming " + defaultMountPoint + " is the only mount point");
             mMounts.add(defaultMountPoint);
         } catch (Exception e)
         {
-            Log.e(TAG, e.getMessage() + ": unknown exception while reading mounts file");
+            Log.e(StorageOptions.class.getCanonicalName(), e.getMessage() + ": unknown exception while reading mounts file");
             mMounts.add(defaultMountPoint);
         }
     }
@@ -155,48 +98,28 @@ public class StorageOptions
         } catch (FileNotFoundException fnfex)
         {
             // if vold.fstab doesn't exist we use the value gathered from the Environment
-            Log.i(TAG, fnfex.getMessage() + ": assuming " + defaultMountPoint + " is the only mount point");
+            Log.i(StorageOptions.class.getCanonicalName(), fnfex.getMessage() + ": assuming " + defaultMountPoint + " is the only mount point");
             mMounts.add(defaultMountPoint);
         } catch (Exception e)
         {
-            Log.e(TAG, e.getMessage() + ": unknown exception while reading vold.fstab file");
+            Log.e(StorageOptions.class.getCanonicalName(), e.getMessage() + ": unknown exception while reading mounts file");
             mMounts.add(defaultMountPoint);
         }
     }
-    
-    private static ArrayList<String> removeDuplicates(ArrayList<String> list) 
-    {
-        ArrayList<String> result = new ArrayList<String>();
-
-        HashSet<String> set = new HashSet<String>();
-
-        for (String item : list) 
-        {
-            if (!set.contains(item)) 
-            {
-                result.add(item);
-                set.add(item);
-            }
-        }
-        return result;
-    }
 
     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.
          */
 
-        if (mVold.size() > 0)
+        for (int i = 0; i < mMounts.size(); i++)
         {
-            for (int i = 0; i < mMounts.size(); i++)
+            String mount = mMounts.get(i);
-            {
+            if (!mVold.contains(mount))
-                String mount = mMounts.get(i);
+                mMounts.remove(i--);
-                if (!mVold.contains(mount))
-                    mMounts.remove(i--);
-            }
         }
 
         // don't need this anymore, clear the vold list to reduce memory
@@ -209,60 +132,18 @@ public class StorageOptions
         /*
          * 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.
          */
-        int t = 0;
+
         for (int i = 0; i < mMounts.size(); i++)
         {
-            t++;
             String mount = mMounts.get(i);
             File root = new File(mount);
             if (!root.exists() || !root.isDirectory() || !root.canWrite())
                 mMounts.remove(i--);
         }
-
-        if (t == 0 && Build.VERSION.SDK_INT >= 16 && findForcemount())
-        {
-            //if none is found lets force it for Jellybean and above...
-            if (System.getenv("EXTERNAL_STORAGE") != null)
-            {
-                File root = new File(System.getenv("EXTERNAL_STORAGE"));
-                if (root.exists() && root.isDirectory() && root.canWrite())
-                {
-                    if(!isRooted())
-                    {
-                        File folder = new File(System.getenv("EXTERNAL_STORAGE")+"/Android/data/net.wagic.app/files");
-                        folder.mkdirs();
-                        mMounts.add(folder.toString());
-                    }
-                    else
-                    {
-                        mMounts.add(System.getenv("EXTERNAL_STORAGE"));
-                    }
-                }
-            }
-
-            if (System.getenv("SECONDARY_STORAGE") != null)
-            {
-                File root = new File(System.getenv("SECONDARY_STORAGE"));
-                if (root.exists() && root.isDirectory() && root.canWrite())
-                {
-                    if(!isRooted())
-                    {
-                        File folder = new File(System.getenv("SECONDARY_STORAGE")+"/Android/data/net.wagic.app/files");
-                        folder.mkdirs();
-                        mMounts.add(folder.toString());
-                    }
-                    else
-                    {
-                        mMounts.add(System.getenv("SECONDARY_STORAGE"));
-                    }
-                }
-            }
-        }
     }
 
     private static void setProperties()
     {
-        Log.d(TAG, "setProperties()");
         /*
          * At this point all the paths in the list should be valid. Build the public properties.
          */
@@ -270,29 +151,14 @@ public class StorageOptions
         ArrayList<String> mLabels = new ArrayList<String>();
 
         int i = 1;
-        if(findForcemount()){
+        for (String path : mMounts)
-            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
-            {//with forcemount menu
+            if ("/mnt/sdcard".equalsIgnoreCase(path))
-                if ("/mnt/sdcard".equalsIgnoreCase(path) || "/storage/sdcard0".equalsIgnoreCase(path))
+                mLabels.add("Built-in Storage");
-                    mLabels.add("Internal SD " + "[" + path + "/]");
+            else
-                else if (path.contains("emulated"))
+                mLabels.add("External SD Card " + i++);
-                    mLabels.add("Emulated SD " + " [" + path + "/]");
-                else
-                    mLabels.add("External SD " + " [" + path + "/]");
-            }
         }
-        else
+
-        {
-            for (String path : mMounts)
-            {
-                // TODO: /mnt/sdcard and emulated are assumed to always mean internal storage. Use this comparison until there is a better way to do this
-                if ("/mnt/sdcard".equalsIgnoreCase(path) || path.contains("emulated"))
-                    mLabels.add("Built-in Storage " + "[" + path + "/]");
-                else
-                    mLabels.add("External SD Card " + "[" + path + "/]");
-            }
-        }
-        
         labels = new String[mLabels.size()];
         mLabels.toArray(labels);
 
@@ -305,119 +171,4 @@ public class StorageOptions
         // use and to prepare it for the next time it's needed.
         mMounts.clear();
     }
-    
+}
-    private static boolean isExternalStorageReadOnly() {
-        String extStorageState = Environment.getExternalStorageState();
-        if (Environment.MEDIA_MOUNTED_READ_ONLY.equals(extStorageState)) {
-            return true;
-        }
-        return false;
-    }
- 
-    private static boolean isExternalStorageAvailable() {
-        String extStorageState = Environment.getExternalStorageState();
-        if (Environment.MEDIA_MOUNTED.equals(extStorageState)) {
-            return true;
-        }
-        return false;
-    }
-    
-    /**
-    * Checks if the device is rooted.
-    *
-    * @return <code>true</code> if the device is rooted, <code>false</code> otherwise.
-    */
-    public static boolean isRooted()
-    {
-        // get from build info
-        String buildTags = android.os.Build.TAGS;
-        if (buildTags != null && buildTags.contains("test-keys"))
-        {
-            return true;
-        }
-
-        // check if /system/app/Superuser.apk is present
-        try
-        {
-            File file = new File("/system/app/Superuser.apk");
-            if (file.exists())
-            {
-                return true;
-            }
-        } catch (Exception e1)
-        {
-            // ignore
-        }
-        try
-        {
-            File file = new File("/system/app/Superuser/Superuser.apk");
-            if (file.exists())
-            {
-                return true;
-            }
-        } catch (Exception e1)
-        {
-            // ignore
-        }
-        //SuperSU
-        try
-        {
-            File file = new File("/system/app/SuperSU.apk");
-            if (file.exists())
-            {
-                return true;
-            }
-        } catch (Exception e1)
-        {
-            // ignore
-        }
-        try
-        {
-            File file = new File("/system/app/SuperSU/SuperSU.apk");
-            if (file.exists())
-            {
-                return true;
-            }
-        } catch (Exception e1)
-        {
-            // ignore
-        }
-        // try executing commands
-        return canExecuteCommand("/system/xbin/which su")
-                || canExecuteCommand("/system/bin/which su") || canExecuteCommand("which su");
-    }
-
-    // executes a command on the system
-    private static boolean canExecuteCommand(String command)
-    {
-        boolean executedSuccesfully;
-        try
-        {
-            Runtime.getRuntime().exec(command);
-            executedSuccesfully = true;
-        } catch (Exception e)
-        {
-            executedSuccesfully = false;
-        }
-
-        return executedSuccesfully;
-    }
-
-    private static boolean findForcemount()
-    {
-        Log.d(TAG, "findForcemount()");
-        try
-        {
-            File file = new File(System.getenv("EXTERNAL_STORAGE") + "/forcemount");
-            if (file.exists())
-            {
-                return true;
-            }
-        } catch (Exception e)
-        {
-            Log.w(TAG, e.getMessage());
-            return false;
-        }
-        return false;
-    }
-}