Skip to content
Permalink
Browse files

Fix Android text bug (no text displaying)

  • Loading branch information...
Zeno- committed Mar 7, 2015
1 parent ffdf8de commit 5698e2baf8008b11706a4bbc4d62c8b584703834
Showing with 79 additions and 80 deletions.
  1. +3 −1 src/game.cpp
  2. +8 −8 src/gettext.h
  3. +63 −68 src/util/string.cpp
  4. +5 −3 src/util/string.h
@@ -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)
{
@@ -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());
@@ -22,22 +22,45 @@ 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>
#include <sstream>
#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);
@@ -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);

0 comments on commit 5698e2b

Please sign in to comment.
You can’t perform that action at this time.