GTalkExt, ICQ, IRC, Jabber: folders restructurization

git-svn-id: http://svn.miranda-ng.org/main/trunk@1890 1316c22d-e87f-b044-9b9b-93d7a3e3ba9c

1 files changed, 541 insertions, 0 deletions

diff --git a/protocols/IcqOscarJ/src/i18n.cpp b/protocols/IcqOscarJ/src/i18n.cpp
new file mode 100644
index 0000000000..535feebcdf
--- /dev/null
+++ b/protocols/IcqOscarJ/src/i18n.cpp
@@ -0,0 +1,541 @@
+// ---------------------------------------------------------------------------80

+//                ICQ plugin for Miranda Instant Messenger

+//                ________________________________________

+//

+// Copyright © 2000-2001 Richard Hughes, Roland Rabien, Tristan Van de Vreede

+// Copyright © 2001-2002 Jon Keating, Richard Hughes

+// Copyright © 2002-2004 Martin Öberg, Sam Kothari, Robert Rainwater

+// Copyright © 2004-2010 Joe Kucera

+//

+// This program is free software; you can redistribute it and/or

+// modify it under the terms of the GNU General Public License

+// as published by the Free Software Foundation; either version 2

+// of the License, or (at your option) any later version.

+//

+// This program is distributed in the hope that it will be useful,

+// but WITHOUT ANY WARRANTY; without even the implied warranty of

+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+// GNU General Public License for more details.

+//

+// You should have received a copy of the GNU General Public License

+// along with this program; if not, write to the Free Software

+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

+//

+// -----------------------------------------------------------------------------

+//  DESCRIPTION:

+//

+//  Contains helper functions to convert text messages between different

+//  character sets.

+//

+// -----------------------------------------------------------------------------

+#include "icqoscar.h"

+

+

+static BOOL bHasCP_UTF8 = FALSE;

+

+

+void InitI18N(void)

+{

+	CPINFO CPInfo;

+

+

+	bHasCP_UTF8 = GetCPInfo(CP_UTF8, &CPInfo);

+}

+

+

+

+// Returns true if the buffer only contains 7-bit characters.

+BOOL __stdcall IsUSASCII(const char *pBuffer, int nSize)

+{

+	for (int nIndex = 0; nIndex < nSize; nIndex++)

+		if (BYTE(pBuffer[nIndex]) > 0x7F)

+			return FALSE;

+

+	return TRUE;

+}

+

+// Returns true if the unicode buffer only contains 7-bit characters.

+BOOL __stdcall IsUnicodeAscii(const WCHAR *pBuffer, int nSize)

+{

+	for (int nIndex = 0; nIndex < nSize; nIndex++)

+		if (WORD(pBuffer[nIndex]) > 0x7F)

+			return FALSE;

+

+	return TRUE;

+}

+

+

+// Scans a string encoded in UTF-8 to verify that it contains

+// only valid sequences. It will return 1 if the string contains

+// only legitimate encoding sequences; otherwise it will return 0;

+// From 'Secure Programming Cookbook', John Viega & Matt Messier, 2003

+int __stdcall UTF8_IsValid(const char *pszInput)

+{

+	int nb;

+	if (!pszInput)

+		return 0;

+

+	for (	BYTE* c = ( BYTE*)pszInput; *c; c += (nb + 1))

+	{

+		if (!(*c & 0x80))

+			nb = 0;

+		else if ((*c & 0xc0) == 0x80) return 0;

+		else if ((*c & 0xe0) == 0xc0) nb = 1;

+		else if ((*c & 0xf0) == 0xe0) nb = 2;

+		else if ((*c & 0xf8) == 0xf0) nb = 3;

+		else if ((*c & 0xfc) == 0xf8) nb = 4;

+		else if ((*c & 0xfe) == 0xfc) nb = 5;

+		else nb = 0;

+

+		for (int i = 1; i<=nb; i++) // we this forward, do not cross end of string

+			if ((*(c + i) & 0xc0) != 0x80)

+				return 0;

+	}

+

+	return 1;

+}

+

+

+int __stdcall get_utf8_size(const WCHAR *unicode)

+{

+	int size = 0;

+	int index = 0;

+	/* calculate the size of the utf-8 string */

+	WCHAR c = unicode[index++];

+	while (c)

+	{

+		if (c < 0x0080) 

+			size += 1;

+		else if (c < 0x0800) 

+			size += 2;

+		else 

+			size += 3;

+		c = unicode[index++];

+	}

+	return size;

+}

+

+

+// returns ansi string in all cases

+char* __stdcall detect_decode_utf8(const char *from)

+{

+	char *temp = NULL;

+

+	if (IsUSASCII(from, strlennull(from)) || !UTF8_IsValid(from) || !utf8_decode(from, &temp)) return (char*)from;

+	SAFE_FREE((void**)&from);

+

+	return temp;

+}

+

+

+/*

+* The following UTF8 routines are

+*

+* Copyright (C) 2001 Peter Harris <peter.harris@hummingbird.com>

+* Copyright (C) 2001 Edmund Grimley Evans <edmundo@rano.org>

+*

+* under a GPL license

+*

+* --------------------------------------------------------------

+* Convert a string between UTF-8 and the locale's charset.

+* Invalid bytes are replaced by '#', and characters that are

+* not available in the target encoding are replaced by '?'.

+*

+* If the locale's charset is not set explicitly then it is

+* obtained using nl_langinfo(CODESET), where available, the

+* environment variable CHARSET, or assumed to be US-ASCII.

+*

+* Return value of conversion functions:

+*

+*  -1 : memory allocation failed

+*   0 : data was converted exactly

+*   1 : valid data was converted approximately (using '?')

+*   2 : input was invalid (but still converted, using '#')

+*   3 : unknown encoding (but still converted, using '?')

+*/

+

+

+

+/*

+* Convert a string between UTF-8 and the locale's charset.

+*/

+char* __stdcall make_utf8_string_static(const WCHAR *unicode, char *utf8, size_t utf_size)

+{

+	int index = 0;

+	unsigned int out_index = 0;

+	unsigned short c;

+

+	c = unicode[index++];

+	while (c)

+	{

+		if (c < 0x080) 

+		{

+			if (out_index + 1 >= utf_size) break;

+			utf8[out_index++] = (unsigned char)c;

+		}

+		else if (c < 0x800) 

+		{

+			if (out_index + 2 >= utf_size) break;

+			utf8[out_index++] = 0xc0 | (c >> 6);

+			utf8[out_index++] = 0x80 | (c & 0x3f);

+		}

+		else

+		{

+			if (out_index + 3 >= utf_size) break;

+			utf8[out_index++] = 0xe0 | (c >> 12);

+			utf8[out_index++] = 0x80 | ((c >> 6) & 0x3f);

+			utf8[out_index++] = 0x80 | (c & 0x3f);

+		}

+		c = unicode[index++];

+	}

+	utf8[out_index] = 0x00;

+

+	return utf8;

+}

+

+

+char* __stdcall make_utf8_string(const WCHAR *unicode)

+{

+	if (!unicode) return NULL;

+

+	/* first calculate the size of the target string */

+	size_t size = get_utf8_size(unicode);

+

+	char *out = (char*)SAFE_MALLOC(size + 1);

+	if (!out)

+		return NULL;

+

+	return make_utf8_string_static(unicode, out, size + 1);

+}

+

+

+WCHAR* __stdcall make_unicode_string_static(const char *utf8, WCHAR *unicode, size_t unicode_size)

+{

+	unsigned int out_index = 0;

+

+	if (utf8)

+	{

+		unsigned int index = 0;

+		unsigned char c = utf8[index++];

+

+		while (c)

+		{

+			if (out_index + 1 >= unicode_size) break;

+			if ((c & 0x80) == 0) 

+			{

+				unicode[out_index++] = c;

+			} 

+			else if ((c & 0xe0) == 0xe0) 

+			{

+				unicode[out_index] = (c & 0x1F) << 12;

+				c = utf8[index++];

+				unicode[out_index] |= (c & 0x3F) << 6;

+				c = utf8[index++];

+				unicode[out_index++] |= (c & 0x3F);

+			}

+			else

+			{

+				unicode[out_index] = (c & 0x3F) << 6;

+				c = utf8[index++];

+				unicode[out_index++] |= (c & 0x3F);

+			}

+			c = utf8[index++];

+		}

+	}

+	unicode[out_index] = 0;

+

+	return unicode;

+}

+

+

+WCHAR* __stdcall make_unicode_string(const char *utf8)

+{

+	int size = 0, index = 0;

+

+	if (!utf8) return NULL;

+

+	/* first calculate the size of the target string */

+	unsigned char c = utf8[index++];

+	while (c) 

+	{

+		if ((c & 0x80) == 0) 

+		{

+			index += 0;

+		}

+		else if ((c & 0xe0) == 0xe0) 

+		{

+			index += 2;

+		}

+		else

+		{

+			index += 1;

+		}

+		size += 1;

+		c = utf8[index++];

+	}

+

+	WCHAR *out = (WCHAR*)SAFE_MALLOC((size + 1) * sizeof(WCHAR));

+	if (!out)

+		return NULL;

+	else

+		return make_unicode_string_static(utf8, out, size + 1);

+}

+

+

+int __stdcall utf8_encode(const char *from, char **to)

+{

+	int wchars = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, from, strlennull(from), NULL, 0);

+

+	if (wchars == 0)

+	{

+#ifdef _DEBUG

+		fprintf(stderr, "Unicode translation error %d\n", GetLastError());

+#endif

+		return -1;

+	}

+

+	WCHAR *unicode = (WCHAR*)_alloca((wchars + 1) * sizeof(WCHAR));

+	ZeroMemory(unicode, (wchars + 1) * sizeof(WCHAR));

+

+	int err = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, from, strlennull(from), unicode, wchars);

+	if (err != wchars)

+	{

+#ifdef _DEBUG

+		fprintf(stderr, "Unicode translation error %d\n", GetLastError());

+#endif

+		return -1;

+	}

+

+	/* On NT-based windows systems, we could use WideCharToMultiByte(), but

+	* MS doesn't actually have a consistent API across win32.

+	*/

+	*to = make_utf8_string(unicode);

+	return 0;

+}

+

+

+char* __stdcall ansi_to_utf8(const char *ansi)

+{

+	char *szUtf = NULL;

+

+	if (strlennull(ansi))

+	{

+		utf8_encode(ansi, &szUtf);

+		return szUtf;

+	}

+

+	return null_strdup("");

+}

+

+

+char* __stdcall ansi_to_utf8_codepage(const char *ansi, WORD wCp)

+{

+	int wchars = strlennull(ansi);

+	WCHAR *unicode = (WCHAR*)_alloca((wchars + 1) * sizeof(WCHAR));

+	ZeroMemory(unicode, (wchars + 1) * sizeof(WCHAR));

+

+	MultiByteToWideChar(wCp, MB_PRECOMPOSED, ansi, wchars, unicode, wchars);

+

+	return make_utf8_string(unicode);

+}

+

+

+// Returns 0 on error, 1 on success

+int __stdcall utf8_decode_codepage(const char *from, char **to, WORD wCp)

+{

+	int nResult = 0;

+

+	_ASSERTE(!(*to)); // You passed a non-zero pointer, make sure it doesnt point to unfreed memory

+

+	// Validate the string

+	if (!UTF8_IsValid(from))

+		return 0;

+

+	// Use the native conversion routines when available

+	if (bHasCP_UTF8)

+	{

+		int inlen = strlennull(from) + 1;

+		WCHAR *wszTemp = (WCHAR *)_alloca(inlen * sizeof(WCHAR));

+    ZeroMemory(wszTemp, inlen * sizeof(WCHAR));

+

+		// Convert the UTF-8 string to UCS

+		if (MultiByteToWideChar(CP_UTF8, 0, from, -1, wszTemp, inlen))

+		{

+			// Convert the UCS string to local ANSI codepage

+			*to = (char*)SAFE_MALLOC(inlen);

+			if (WideCharToMultiByte(wCp, 0, wszTemp, -1, *to, inlen, NULL, NULL))

+			{

+				nResult = 1;

+			}

+			else

+			{

+				SAFE_FREE(to);

+			}

+		}

+	}

+	else

+	{

+		int chars = strlennull(from) + 1;

+		WCHAR *unicode = (WCHAR*)_alloca(chars * sizeof(WCHAR));

+		make_unicode_string_static(from, unicode, chars);

+

+		chars = WideCharToMultiByte(wCp, WC_COMPOSITECHECK, unicode, -1, NULL, 0, NULL, NULL);

+

+		if (chars == 0)

+		{

+#ifdef _DEBUG

+			fprintf(stderr, "Unicode translation error %d\n", GetLastError());

+#endif

+			return 0;

+		}

+

+		*to = (char*)SAFE_MALLOC((chars + 1)*sizeof(char));

+		if (*to == NULL)

+		{

+#ifdef _DEBUG

+			fprintf(stderr, "Out of memory processing string to local charset\n");

+#endif

+			return 0;

+		}

+

+		int err = WideCharToMultiByte(wCp, WC_COMPOSITECHECK, unicode, -1, *to, chars, NULL, NULL);

+		if (err != chars)

+		{

+#ifdef _DEBUG

+			fprintf(stderr, "Unicode translation error %d\n", GetLastError());

+#endif

+			SAFE_FREE(to);

+			return 0;

+		}

+

+		nResult = 1;

+	}

+

+	return nResult;

+}

+

+

+// Standard version with current codepage

+int __stdcall utf8_decode(const char *from, char **to)

+{

+	return utf8_decode_codepage(from, to, CP_ACP);

+}

+

+

+// Returns 0 on error, 1 on success

+int __stdcall utf8_decode_static(const char *from, char *to, int to_size)

+{

+	int nResult = 0;

+

+	_ASSERTE(to); // You passed a zero pointer

+

+	// Validate the string

+	if (!UTF8_IsValid(from))

+		return 0;

+

+  // Clear target

+  ZeroMemory(to, to_size);

+

+	// Use the native conversion routines when available

+	if (bHasCP_UTF8)

+	{

+		int inlen = strlennull(from) + 1;

+		WCHAR *wszTemp = (WCHAR*)_alloca(inlen * sizeof(WCHAR));

+		ZeroMemory(wszTemp, inlen * sizeof(WCHAR));

+

+		// Convert the UTF-8 string to UCS

+		if (MultiByteToWideChar(CP_UTF8, 0, from, -1, wszTemp, inlen))

+		{

+			// Convert the UCS string to local ANSI codepage

+			if (WideCharToMultiByte(CP_ACP, 0, wszTemp, -1, to, to_size, NULL, NULL))

+			{

+				nResult = 1;

+			}

+		}

+	}

+	else

+	{

+		size_t chars = strlennull(from) + 1;

+		WCHAR *unicode = (WCHAR*)_alloca(chars * sizeof(WCHAR));

+

+		make_unicode_string_static(from, unicode, chars);

+

+		WideCharToMultiByte(CP_ACP, WC_COMPOSITECHECK, unicode, -1, to, to_size, NULL, NULL);

+

+		nResult = 1;

+	}

+

+	return nResult;

+}

+

+

+WCHAR* __stdcall ansi_to_unicode(const char *ansi)

+{

+	int wchars = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, ansi, strlennull(ansi), NULL, 0);

+

+	if (wchars == 0)

+	{

+#ifdef _DEBUG

+		fprintf(stderr, "Unicode translation error %d\n", GetLastError());

+#endif

+		return NULL;

+	}

+

+	WCHAR *unicode = (WCHAR*)SAFE_MALLOC((wchars + 1) * sizeof(WCHAR));

+

+	int err = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, ansi, strlennull(ansi), unicode, wchars);

+	if (err != wchars)

+	{

+#ifdef _DEBUG

+		fprintf(stderr, "Unicode translation error %d\n", GetLastError());

+#endif

+    SAFE_FREE(&unicode);

+		return NULL;

+	}

+  return unicode;

+}

+

+

+char* __stdcall unicode_to_ansi_static(const WCHAR *unicode, char *ansi, int ansi_size)

+{

+  ZeroMemory(ansi, ansi_size);

+

+	if (WideCharToMultiByte(CP_ACP, WC_COMPOSITECHECK, unicode, strlennull(unicode), ansi, ansi_size, NULL, NULL) > 1)

+		return ansi;

+

+  return NULL;

+}

+

+

+char* __stdcall unicode_to_ansi(const WCHAR *unicode)

+{

+	int chars = WideCharToMultiByte(CP_ACP, WC_COMPOSITECHECK, unicode, strlennull(unicode), NULL, 0, NULL, NULL);

+

+	if (chars == 0)

+	{

+#ifdef _DEBUG

+		fprintf(stderr, "Unicode translation error %d\n", GetLastError());

+#endif

+		return NULL;

+	}

+

+	char* ansi = (char*)SAFE_MALLOC((chars + 1)*sizeof(char));

+	if (ansi == NULL)

+	{

+#ifdef _DEBUG

+		fprintf(stderr, "Out of memory processing string to local charset\n");

+#endif

+		return NULL;

+	}

+

+	int err = WideCharToMultiByte(CP_ACP, WC_COMPOSITECHECK, unicode, strlennull(unicode), ansi, chars, NULL, NULL);

+	if (err != chars)

+	{

+#ifdef _DEBUG

+		fprintf(stderr, "Unicode translation error %d\n", GetLastError());

+#endif

+		return NULL;

+	}

+

+	return ansi;

+}