Fix Android text bug (no text displaying)

diff --git a/src/game.cpp b/src/game.cpp
index 87ee081bed097c1a8a35aa86a4dd27981a6b6c46..be8d4e6795a5e5b89356990428446f9ebf78bc16 100644 (file)
--- a/src/game.cpp
+++ b/src/game.cpp
@@ -4175,7 +4175,9 @@ inline void Game::limitFps(FpsControl *fps_timings, f32 *dtime)
        fps_timings->last_time = time;
 }
 
-
+// Note: This will free (using delete[])! \p msg. If you want to use it later,
+// pass a copy of it to this function
+// Note: \p msg must be allocated using new (not malloc())
 void Game::showOverlayMessage(const wchar_t *msg, float dtime,
                int percent, bool draw_clouds)
 {

diff --git a/src/gettext.h b/src/gettext.h
index dce45fa3aafd3b339bbf843cbcb6fc5ab3b53c5b..8235efa8ac0b3ef7f998d7dd364860610810060c 100644 (file)
--- a/src/gettext.h
+++ b/src/gettext.h
@@ -23,31 +23,31 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "config.h" // for USE_GETTEXT
 
 #if USE_GETTEXT
-#include <libintl.h>
+       #include <libintl.h>
 #else
-#define gettext(String) String
+       #define gettext(String) String
 #endif
 
 #define _(String) gettext(String)
-#define gettext_noop(String) String
-#define N_(String) gettext_noop (String)
+#define gettext_noop(String) (String)
+#define N_(String) gettext_noop((String))
 
 #ifdef _MSC_VER
-void init_gettext(const char *path, const std::string &configured_language, int argc, char** argv);
+void init_gettext(const char *path, const std::string &configured_language,
+               int argc, char** argv);
 #else
 void init_gettext(const char *path, const std::string &configured_language);
 #endif
 
-extern const wchar_t *narrow_to_wide_c(const char *mbs);
-extern std::wstring narrow_to_wide(const std::string &mbs);
+extern wchar_t *narrow_to_wide_c(const char *str);
 
 // You must free the returned string!
+// The returned string is allocated using new
 inline const wchar_t *wgettext(const char *str)
 {
        return narrow_to_wide_c(gettext(str));
 }
 
-// Gettext under MSVC needs this strange way. Just don't ask...
 inline std::wstring wstrgettext(const std::string &text)
 {
        const wchar_t *tmp = wgettext(text.c_str());

diff --git a/src/util/string.cpp b/src/util/string.cpp
index c48abe835b1840c8ce1e63b8679154e84c0b0e3c..651293bfef0e34c0e4a03d6347dd71cc7ee08610 100644 (file)
--- a/src/util/string.cpp
+++ b/src/util/string.cpp
@@ -22,9 +22,9 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "numeric.h"
 #include "log.h"
 
+#include "sha1.h"
 #include "base64.h"
 #include "hex.h"
-#include "sha1.h"
 #include "../porting.h"
 
 #include <algorithm>
@@ -32,12 +32,35 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include <iomanip>
 #include <map>
 
+static bool parseHexColorString(const std::string &value, video::SColor &color);
+static bool parseNamedColorString(const std::string &value, video::SColor &color);
+
+
+// You must free the returned string!
+// The returned string is allocated using new
+wchar_t *narrow_to_wide_c(const char *str)
+{
+       wchar_t* nstr = 0;
 #if defined(_WIN32)
-#include <windows.h>  // MultiByteToWideChar
+       int nResult = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR) str, -1, 0, 0);
+       if (nResult == 0) {
+               errorstream<<"gettext: MultiByteToWideChar returned null"<<std::endl;
+       } else {
+               nstr = new wchar_t[nResult];
+               MultiByteToWideChar(CP_UTF8, 0, (LPCSTR) str, -1, (WCHAR *) nstr, nResult);
+       }
+#else
+       size_t len = strlen(str);
+       nstr = new wchar_t[len+1];
+
+       std::wstring intermediate = narrow_to_wide(str);
+       memset(nstr, 0, (len + 1) * sizeof(wchar_t));
+       memcpy(nstr, intermediate.c_str(), len * sizeof(wchar_t));
 #endif
 
-static bool parseHexColorString(const std::string &value, video::SColor &color);
-static bool parseNamedColorString(const std::string &value, video::SColor &color);
+       return nstr;
+}
+
 
 #ifdef __ANDROID__
 
@@ -63,84 +86,55 @@ int wctomb(char *s, wchar_t wc)
 
 int mbtowc(wchar_t *pwc, const char *s, size_t n)
 {
-       if (s == NULL || *s == '\0')
-               return -1;
+       std::wstring intermediate = narrow_to_wide(s);
 
-       const wchar_t *tmp = narrow_to_wide_c(s);
-       bool success = tmp[0] != '\0';
+       if (intermediate.length() > 0) {
+               *pwc = intermediate[0];
+               return 1;
+       }
+       else {
+               return -1;
+       }
+}
 
-       if (success)
-               *pwc = tmp[0];
+std::wstring narrow_to_wide(const std::string &mbs) {
+       size_t wcl = mbs.size();
 
-       delete tmp;
+       std::wstring retval = L"";
 
-       return success ? 1 : -1;
-}
+       for (unsigned int i = 0; i < wcl; i++) {
+               if (((unsigned char) mbs[i] >31) &&
+                ((unsigned char) mbs[i] < 127)) {
 
-// You must free the returned string!
-const wchar_t *narrow_to_wide_c(const char *mbs)
-{
-       size_t mbl = strlen(mbs);
-       wchar_t *wcs = new wchar_t[mbl + 1];
-
-       size_t i, dest_i = 0;
-       for (i = 0; i < mbl; i++) {
-               if (((unsigned char) mbs[i] > 31) &&
-                               ((unsigned char) mbs[i] < 127)) {
-                       wcs[dest_i++] = wide_chars[(unsigned char) mbs[i] - 32];
+                       retval += wide_chars[(unsigned char) mbs[i] -32];
                }
                //handle newline
                else if (mbs[i] == '\n') {
-                       wcs[dest_i++] = L'\n';
+                       retval += L'\n';
                }
        }
-       wcs[dest_i] = '\0';
-
-       return wcs;
-}
 
-#else
-
-// You must free the returned string!
-const wchar_t *narrow_to_wide_c(const char *mbs)
-{
-       wchar_t *wcs = NULL;
-#if defined(_WIN32)
-       int nResult = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR) mbs, -1, 0, 0);
-       if (nResult == 0) {
-               errorstream << "gettext: MultiByteToWideChar returned null" << std::endl;
-       } else {
-               wcs = new wchar_t[nResult];
-               MultiByteToWideChar(CP_UTF8, 0, (LPCSTR) mbs, -1, (WCHAR *) wcs, nResult);
-       }
-#else
-       size_t wcl = mbstowcs(NULL, mbs, 0);
-       if (wcl == (size_t) -1)
-               return NULL;
-       wcs = new wchar_t[wcl + 1];
-       size_t l = mbstowcs(wcs, mbs, wcl);
-       assert(l != (size_t) -1); // Should never happen if the last call worked
-       wcs[l] = '\0';
-#endif
-
-       return wcs;
+       return retval;
 }
 
-#endif
+#else // not Android
 
-std::wstring narrow_to_wide(const std::string& mbs)
+std::wstring narrow_to_wide(const std::string &mbs)
 {
        size_t wcl = mbs.size();
        Buffer<wchar_t> wcs(wcl + 1);
-       size_t l = mbstowcs(*wcs, mbs.c_str(), wcl);
-       if (l == (size_t)(-1))
+       size_t len = mbstowcs(*wcs, mbs.c_str(), wcl);
+       if (len == (size_t)(-1))
                return L"<invalid multibyte string>";
-       wcs[l] = 0;
+       wcs[len] = 0;
        return *wcs;
 }
 
+#endif
+
 #ifdef __ANDROID__
-std::string wide_to_narrow(const std::wstring& wcs) {
+
+std::string wide_to_narrow(const std::wstring &wcs) {
        size_t mbl = wcs.size()*4;
 
        std::string retval = "";
@@ -165,17 +159,18 @@ std::string wide_to_narrow(const std::wstring& wcs) {
 
        return retval;
 }
-#else
-std::string wide_to_narrow(const std::wstring& wcs)
+
+#else // not Android
+
+std::string wide_to_narrow(const std::wstring &wcs)
 {
-       size_t mbl = wcs.size()*4;
+       size_t mbl = wcs.size() * 4;
        SharedBuffer<char> mbs(mbl+1);
-       size_t l = wcstombs(*mbs, wcs.c_str(), mbl);
-       if(l == (size_t)(-1)) {
+       size_t len = wcstombs(*mbs, wcs.c_str(), mbl);
+       if (len == (size_t)(-1))
                return "Character conversion failed!";
-       }
        else
-               mbs[l] = 0;
+               mbs[len] = 0;
        return *mbs;
 }
 
@@ -188,7 +183,7 @@ std::string wide_to_narrow(const std::wstring& wcs)
 // compatibility with password-less players).
 std::string translatePassword(std::string playername, std::wstring password)
 {
-       if(password.length() == 0)
+       if (password.length() == 0)
                return "";
 
        std::string slt = playername + wide_to_narrow(password);

diff --git a/src/util/string.h b/src/util/string.h
index 388184ca49a645cdd480ebd042892f97763ce7a7..dc520e3a8947c91e8183873b68fe1d0bb611ccd5 100644 (file)
--- a/src/util/string.h
+++ b/src/util/string.h
@@ -36,11 +36,13 @@ struct FlagDesc {
        u32 flag;
 };
 
+
 // You must free the returned string!
-const wchar_t *narrow_to_wide_c(const char *mbs);
+// The returned string is allocated using new
+wchar_t *narrow_to_wide_c(const char *str);
 
-std::wstring narrow_to_wide(const std::string& mbs);
-std::string wide_to_narrow(const std::wstring& wcs);
+std::wstring narrow_to_wide(const std::string &mbs);
+std::string wide_to_narrow(const std::wstring &wcs);
 std::string translatePassword(std::string playername, std::wstring password);
 std::string urlencode(std::string str);
 std::string urldecode(std::string str);