gchar *mrim_package_read_LPSA(MrimPackage *pack) {
gsize str_len = mrim_package_read_UL(pack);
if (str_len) {
gchar *str = g_new(gchar, str_len + 1);
mrim_package_read_raw(pack, str, str_len);
str[str_len] = '\0';
gchar *string = g_convert(str, -1, "UTF8" , "CP1251", NULL, NULL, NULL);
g_free(str);
return string;
} else {
return NULL;
}
}
gchar* TextCodecGtk::gconvert_till_error(const char* str,
gssize length,
const char* to_codeset,
const char* from_codeset,
gsize *bytes_read,
gsize *bytes_written,
GError **error)
{
//first we try to convert the string
GError* internal_error = NULL;
gchar* result = g_convert (str,
length,
to_codeset,
from_codeset,
bytes_read,
bytes_written,
&internal_error);
//if there are unsupported characters
//bytes_read would store the number of bytes that could be successfully converted
//so we try to convert only that
if(!result && (*bytes_read < length) && internal_error )
{
result = g_convert ( str,
*bytes_read,
to_codeset,
from_codeset,
bytes_read,
bytes_written,
NULL);
}
if(error)
*error = internal_error;
else if(internal_error)
g_error_free(internal_error);
return result;
}
gboolean gnomegadu_protocol_send_message (gchar * uin_str, gchar *msg)
{
gchar *msg_windows1250 = g_convert (msg, strlen (msg), "WINDOWS-1250", "UTF-8", NULL, NULL, NULL);
if (!gnomegadu_protocol_check_connected())
return FALSE;
if (gg_send_message(gnomegadu_gadugadu_session, GG_CLASS_CHAT, g_ascii_strtod (uin_str, NULL), msg_windows1250) == -1)
return FALSE;
g_free(msg_windows1250);
return TRUE;
}
static void
store_meta(gpointer key,
gpointer value,
gpointer user_data)
{
GwyContainer *meta = (GwyContainer*)user_data;
gchar *cval;
if (!(cval = g_convert(value, strlen(value), "UTF-8", "ISO-8859-1",
NULL, NULL, NULL)))
return;
gwy_container_set_string_by_name(meta, key, cval);
}
static void utf32to8(char *t, char *s)
{
gsize rn,wn=0;
GError *err = NULL;
char *utf8 = g_convert(s, 4, "UTF-8", "UTF-32", &rn, &wn, &err);
if (utf8) {
memcpy(t, utf8, wn);
g_free(utf8);
}
t[wn]=0;
}
/* Length must be passed, as the string might be Unicode, in which case we can't
* count zeroes (see strlen call below). */
gchar *
convert_string_1 (const gchar *string, gssize length, const gchar *from_codeset,
const gchar *to_codeset, const gboolean display_error)
{
gchar *output;
GError *error = NULL;
gsize bytes_written;
g_return_val_if_fail (string != NULL, NULL);
output = g_convert(string, length, to_codeset, from_codeset, NULL, &bytes_written, &error);
//output = g_convert_with_fallback(string, length, to_codeset, from_codeset, "?", NULL, &bytes_written, &error);
if (output == NULL)
{
gchar *escaped_str = g_strescape(string, NULL);
if (display_error)
{
Log_Print(LOG_ERROR,"convert_string(): Failed conversion from charset '%s' to '%s'. "
"String '%s'. Errcode %d (%s).",
from_codeset, to_codeset, escaped_str, error->code, error->message);
}
g_free(escaped_str);
g_error_free(error);
// Return the input string without converting it. If the string is
// displayed in the UI, it must be in UTF-8!
if ( (g_ascii_strcasecmp(to_codeset, "UTF-8"))
|| (g_utf8_validate(string, -1, NULL)) )
{
return g_strdup(string);
}
}else
{
// Patch from Alexey Illarionov:
// g_convert returns null-terminated string only with one \0 at the
// end. It can cause some garbage at the end of a string for UTF-16.
// The second \0 should be set manually.
gchar *new_output;
new_output = g_realloc (output, bytes_written + 2);
if (new_output != NULL)
{
output = new_output;
output[bytes_written] = output[bytes_written + 1] = 0;
}
}
//g_print("from %s => len: %d, string: '%s'\n (%x %x %x %x %x %x %x %x)\n",from_codeset,length,string,string[0],string[1],string[2],string[3],string[4],string[5],string[6],string[7]);
//g_print("to %s => len: %d, output: '%s'\n (%x %x %x %x %x %x %x %x)\n\n",to_codeset,bytes_written+2,output,output[0],output[1],output[2],output[3],output[4],output[5],output[6],output[7]);
return output;
}
void WAttGtk::activate_cmd_scrolled_ok(GtkWidget* w, gpointer data)
{
WAttGtk* watt = (WAttGtk*)data;
gchar *text, *textutf8;
unsigned char* s;
int sts;
if (watt->input_open) {
GtkTextIter start_iter, end_iter;
gtk_text_buffer_get_start_iter(watt->cmd_scrolled_buffer, &start_iter);
gtk_text_buffer_get_end_iter(watt->cmd_scrolled_buffer, &end_iter);
textutf8 = gtk_text_buffer_get_text(
watt->cmd_scrolled_buffer, &start_iter, &end_iter, FALSE);
text = g_convert(textutf8, -1, "ISO8859-1", "UTF-8", NULL, NULL, NULL);
g_free(textutf8);
if (text) {
// Replace ctrl characters with space
for (s = (unsigned char*)text; *s; s++) {
if (*s < ' ' && *s != 10 && *s != 13)
*s = ' ';
}
sts = ((WAttNav*)watt->wattnav)
->set_attr_value(watt->input_node, watt->input_name, text);
}
g_object_set(watt->cmd_scrolledinput, "visible", FALSE, NULL);
watt->set_prompt("");
watt->input_open = 0;
int w, h;
gdk_drawable_get_size(watt->pane->window, &w, &h);
gtk_paned_set_position(GTK_PANED(watt->pane), h - 50);
((WAttNav*)watt->wattnav)->redraw();
((WAttNav*)watt->wattnav)->set_inputfocus();
if (text)
g_free(text);
else
watt->message('E', "Input error, invalid character");
if (watt->pending_close) {
if (watt->close_cb)
(watt->close_cb)(watt);
else
delete watt;
}
}
}
static TEspeakSuccess espeak_set_punctuation_list_from_utf8(const gchar * punct)
{
TEspeakSuccess result = ERROR;
wchar_t *wc_punct =
(wchar_t *) g_convert(punct, -1, "wchar_t", "utf-8", NULL, NULL,
NULL);
if (wc_punct != NULL) {
espeak_ERROR ret = espeak_SetPunctuationList(wc_punct);
if (ret == EE_OK)
result = OK;
g_free(wc_punct);
}
return result;
}
void XttTblGtk::set_prompt(const char* prompt)
{
if (streq(prompt, "")) {
g_object_set(cmd_prompt, "visible", FALSE, NULL);
g_object_set(msg_label, "visible", TRUE, NULL);
} else {
char* promptutf8
= g_convert(prompt, -1, "UTF-8", "ISO8859-1", NULL, NULL, NULL);
g_object_set(msg_label, "visible", FALSE, NULL);
g_object_set(cmd_prompt, "visible", TRUE, "label", promptutf8, NULL);
g_free(promptutf8);
}
}
gchar *Lyric_Str2UTF8(const gchar * lpszStr)
{
gchar * lpszUTF8 = aud_str_to_utf8(lpszStr);
if (lpszUTF8)
{
if(g_strstr_len(lpszUTF8, strlen(lpszUTF8), "??????"))
{
g_free(lpszUTF8);
return MyStr2UTF8(lpszStr);
}
return lpszUTF8;
}
return g_convert(lpszStr, strlen(lpszStr), "UTF-8", "GBK", NULL, NULL, NULL);
}
char *
utf8_to_fs_charset(const char *path_utf8)
{
gchar *p;
p = g_convert(path_utf8, -1,
fs_charset, "utf-8",
NULL, NULL, NULL);
if (p == NULL)
/* fall back to UTF-8 */
p = g_strdup(path_utf8);
return p;
}
char *recode_out(const SERVER_REC *server, const char *str, const char *target)
{
#ifdef HAVE_GLIB2
char *recoded = NULL;
const char *from = NULL;
const char *to = NULL;
char *translit_to = NULL;
gboolean translit, term_is_utf8, recode;
int len;
if (!str)
return NULL;
recode = settings_get_bool("recode");
if (!recode)
return g_strdup(str);
len = strlen(str);
translit = settings_get_bool("recode_transliterate");
if (server != NULL && server->tag != NULL && target != NULL) {
char *tagtarget = g_strdup_printf("%s/%s", server->tag, target);
to = iconfig_get_str("conversions", tagtarget, NULL);
g_free(tagtarget);
}
if (to == NULL || *to == '\0')
to = iconfig_get_str("conversions", target, NULL);
if ((to == NULL || *to == '\0') && server != NULL)
to = iconfig_get_str("conversions", server->tag, NULL);
if (to == NULL || *to == '\0')
/* default outgoing charset if set */
to = settings_get_str("recode_out_default_charset");
if (to && *to != '\0') {
if (translit && !is_translit(to))
to = translit_to = g_strconcat(to ,"//TRANSLIT", NULL);
term_is_utf8 = recode_get_charset(&from);
recoded = g_convert(str, len, to, from, NULL, NULL, NULL);
}
g_free(translit_to);
if (!recoded)
recoded = g_strdup(str);
return recoded;
#else
return g_strdup(str);
#endif
}
gchar *slurpfile(const gchar *fname, GError **err)
{
gchar *inbuf = NULL, *outbuf = NULL;
gsize inlen, outlen;
if (g_file_get_contents(fname, &inbuf, &inlen, err)) {
if (g_ascii_strcasecmp(inputEncoding, "UTF-8") != 0) {
outbuf = g_convert(inbuf, inlen, "UTF-8", inputEncoding, NULL, &outlen, err);
g_free(inbuf);
}
else
outbuf = inbuf;
}
return outbuf;
}
static char*
get_new_name(const char* name, const char* encoding)
{
char* new_name = NULL;
if (encoding == NULL)
return NULL;
if (g_utf8_validate(name, -1, NULL)) {
char* unescaped = g_uri_unescape_string(name, NULL);
if (g_utf8_validate(unescaped, -1, NULL)) {
// A filename from MacOSX is usually in NFD.
// So, if the filename is not in NFC, try to make it NFC.
char* normalized = g_utf8_normalize(unescaped, -1, G_NORMALIZE_NFC);
if (normalized != NULL) {
// Som filenames are valid UTF-8 form,
// but are misconverted with wrong encoding.
// In that case, the names are illegible.
// So, we try to reconvert it with the user selected encoding
new_name = get_reconverted_name(normalized, encoding);
if (new_name != NULL) {
g_free(normalized);
} else {
new_name = normalized;
}
}
g_free(unescaped);
} else {
new_name = g_convert(unescaped, -1, "UTF-8", encoding, NULL, NULL, NULL);
g_free(unescaped);
}
} else {
new_name = g_convert(name, -1, "UTF-8", encoding, NULL, NULL, NULL);
}
return new_name;
}
/**
* Converts the passed-in string from UTF-8 to ASCII for http transmisison.
*
* @param pczInString String to convert
*
* @return The converted string which MUST BE FREED BY THE CALLER.
*/
static gchar *
convertToASCII(const gchar *pczInString)
{
// for UTF-8 to ASCII conversions
setlocale(LC_CTYPE, "en_US");
GError * pError = NULL;
gsize szBytesRead = 0;
gsize szBytesWritten = 0;
gchar * pcConvertedString = g_convert(pczInString,
strlen(pczInString),
"ASCII//TRANSLIT",
"UTF-8",
&szBytesRead,
&szBytesWritten,
&pError);
if (pError)
{
LXW_LOG(LXW_ERROR, "yahooutil::convertToASCII(%s): Error: %s",
pczInString, pError->message);
g_error_free(pError);
pcConvertedString = g_strndup(pczInString, strlen(pczInString));
}
// now escape space, if any
xmlChar * pxEscapedString = xmlURIEscapeStr((const xmlChar *)pcConvertedString, NULL);
if (pxEscapedString)
{
// release ConvertedString, reset it, then release EscapedString.
// I know it's confusing, but keeps everything as a gchar and g_free
g_free(pcConvertedString);
pcConvertedString = g_strndup((const gchar *)pxEscapedString,
strlen((const gchar *)pxEscapedString));
xmlFree(pxEscapedString);
}
// restore locale to default
setlocale(LC_CTYPE, "");
return pcConvertedString;
}
TCHAR *au_fs (const char *src) {
#ifdef NO_TRANSLATION
if (src == NULL) return NULL;
return strdup(src);
#else
gsize read, written;
gchar *result = g_convert(src, -1, "UTF-8",
"ISO-8859-1", &read, &written, NULL);
if (result == NULL) {
write_log("WARNING: au_fs_copy failed to convert string %s", src);
return strdup("");
}
return result;
#endif
}
static char *
hf_probe_volume_get_label (const struct volume_id *vid)
{
char *label = NULL;
if (vid && *vid->label)
{
if (g_utf8_validate(vid->label, -1, NULL))
label = g_strdup(vid->label);
else /* assume ISO8859-1 */
label = g_convert(vid->label, -1, "UTF-8", "ISO8859-1", NULL, NULL, NULL);
}
return label;
}
gchar *
encode_to_originally(const gchar *str)
{
GError* error = NULL;
if(!str)
return NULL;
gchar* pgb = g_convert(str, -1, "iso-8859-1", "utf-8", NULL, NULL, &error);
if(error)
{
fprintf(stderr,"%s to originally %s\n",str,error->message);
g_error_free(error);
pgb = NULL;
}
return pgb;
}
gchar *
g_locale_from_utf8 (const gchar *utf8string,
gssize len,
gsize *bytes_read,
gsize *bytes_written,
GError **error)
{
const gchar *charset;
if (g_get_charset (&charset))
return g_strdup (utf8string);
else
return g_convert (utf8string, len,
charset, "UTF-8", bytes_read, bytes_written, error);
}
static GValue *
str_to_gvalue (const char *str, gboolean try_convert)
{
GValue *val;
/* Empty */
if (!str || strlen (str) < 1)
return NULL;
if (!g_utf8_validate (str, -1, NULL)) {
if (try_convert && !(str = g_convert (str, -1, "ISO-8859-1", "UTF-8", NULL, NULL, NULL)))
str = g_convert (str, -1, "C", "UTF-8", NULL, NULL, NULL);
if (!str)
/* Invalid */
return NULL;
}
val = g_slice_new0 (GValue);
g_value_init (val, G_TYPE_STRING);
g_value_set_string (val, str);
return val;
}
gchar *
convert_fallback(gchar const *text, gssize size, gchar const *fallback)
{
gchar *res;
gsize read, written;
GString *str = g_string_new("");
while ((res = g_convert(text, size, "UTF-8", "ASCII", &read, &written, NULL))
== NULL) {
res = g_convert(text, read, "UTF-8", "ASCII", NULL, NULL, NULL);
str = g_string_append(str, res);
str = g_string_append(str, fallback);
text = text + read + 1;
size = size - read;
}
str = g_string_append(str, res);
g_free(res);
res = str->str;
g_string_free(str, FALSE);
return res;
}
void packet_add_string(packet_constructor_t *pc, unsigned char *v)
{
packet_add_field(pc);
GError *error = NULL;
size_t conv_len;
char *conv = g_convert((char *) v, -1, "UTF16BE", "UTF8", NULL, &conv_len, &error);
if (!conv)
dief("g_convert UTF8->UTF16BE failed (error: %s, string: '%s')", error->message, (char *) v);
unsigned char lenb[2];
jshort_write(lenb, conv_len/2);
g_byte_array_append(pc->data, lenb, 2);
g_byte_array_append(pc->data, (unsigned char*)conv, conv_len);
pc->offset += 2 + conv_len;
g_free(conv);
}
void XttTblGtk::valchanged_cmd_input(GtkWidget* w, gpointer data)
{
XttTbl* xtt = (XttTbl*)data;
int sts;
char *text, *textutf8;
textutf8 = gtk_editable_get_chars(GTK_EDITABLE(w), 0, -1);
text = g_convert(textutf8, -1, "ISO8859-1", "UTF-8", NULL, NULL, NULL);
g_free(textutf8);
sts = xtt->command(text);
g_object_set(w, "visible", FALSE, NULL);
xtt->set_prompt("");
xtt->command_open = 0;
xtt->tblnav->set_inputfocus();
}
gchar*
gsl_convert_to_utf8 (const gchar *codeset,
const gchar *string)
{
gchar *result;
g_return_val_if_fail (codeset != NULL, NULL);
if (!string)
return NULL;
result = g_convert (string, strlen (string), GSL_CODESET_UTF8, codeset, NULL, NULL, NULL);
if (!result)
result = g_strconcat ("??unknown-codeset:", codeset, "??", NULL);
return result;
}
static void
store_meta(gpointer key,
gpointer value,
gpointer user_data)
{
GwyContainer *meta = (GwyContainer*)user_data;
if (g_utf8_validate(value, -1, NULL)) {
gwy_container_set_string_by_name(meta, key, g_strdup(value));
}
else {
gchar *s = g_convert(value, -1, "UTF-8", "CP1252", NULL, NULL, NULL);
if (s)
gwy_container_set_string_by_name(meta, key, s);
}
}
const gchar *
cut_take_convert_helper (const gchar *string,
const gchar *to_code_set,
const gchar *from_code_set,
CutCallbackFunction callback)
{
gchar *converted;
GError *error = NULL;
converted = g_convert(string, -1, to_code_set, from_code_set,
NULL, NULL, &error);
gcut_assert_error_helper(error, "error");
if (callback)
callback();
return cut_take_string(converted);
}
static void
store_meta(gpointer key,
gpointer value,
gpointer user_data)
{
GwyContainer *meta = (GwyContainer*)user_data;
if (g_utf8_validate(value, -1, NULL)) {
gwy_container_set_string_by_name(meta, key, g_strdup(value));
}
else {
// FIXME: Is this Windows-locale dependent?
gchar *s = g_convert(value, -1, "UTF-8", "GB2312", NULL, NULL, NULL);
if (s)
gwy_container_set_string_by_name(meta, key, s);
}
}
gboolean mape_edit_view_save(MapeEditView* view,
const gchar* filename,
GError** error)
{
GtkTextBuffer* buffer;
GtkTextIter begin;
GtkTextIter end;
gchar* source;
gchar* conv;
gboolean result;
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(view->view) );
gtk_text_buffer_get_start_iter(buffer, &begin);
gtk_text_buffer_get_end_iter(buffer, &end);
source = gtk_text_buffer_get_text(buffer, &begin, &end, TRUE);
conv = g_convert(
source,
-1,
view->encoding,
"UTF-8",
NULL,
NULL,
error
);
g_free(source);
if(conv == NULL) return FALSE;
result = g_file_set_contents(filename, conv, -1, error);
g_free(conv);
if(result == FALSE) return FALSE;
gtk_text_buffer_set_modified(
gtk_text_view_get_buffer(GTK_TEXT_VIEW(view->view)),
FALSE
);
mape_edit_view_set_filename(view, filename);
/* Rerender with new file path --
* different Script.c lookup for algo=script overlays */
mape_edit_view_reload(view);
return TRUE;
}
static void
chmfile_file_info(ChmFile *chmfile)
{
struct chmFile *cfd;
cfd = chm_open(chmfile->filename);
if (cfd == NULL) {
g_error(_("Can not open chm file %s."), chmfile->filename);
return;
}
chmfile_system_info(cfd, chmfile);
chmfile_windows_info(cfd, chmfile);
/* Convert book title to UTF-8 */
if (chmfile->title != NULL && chmfile->encoding != NULL) {
gchar *title_utf8;
title_utf8 = g_convert(chmfile->title, -1, "UTF-8",
chmfile->encoding,
NULL, NULL, NULL);
g_free(chmfile->title);
chmfile->title = title_utf8;
}
/* Convert filename to UTF-8 */
if (chmfile->hhc != NULL && chmfile->encoding != NULL) {
gchar *filename_utf8;
filename_utf8 = convert_filename_to_utf8(chmfile->hhc, chmfile->encoding);
g_free(chmfile->hhc);
chmfile->hhc = filename_utf8;
}
if (chmfile->hhk != NULL && chmfile->encoding != NULL) {
gchar *filename_utf8;
filename_utf8 = convert_filename_to_utf8(chmfile->hhk, chmfile->encoding);
g_free(chmfile->hhk);
chmfile->hhk = filename_utf8;
}
chm_close(cfd);
}
/**
* mono_utf8_from_external:
* @in: pointer to the string buffer.
*
* Tries to turn a NULL-terminated string into UTF8.
*
* First, see if it's valid UTF8, in which case there's nothing more
* to be done. Next, run through the colon-separated encodings in
* MONO_EXTERNAL_ENCODINGS and do an iconv conversion on each,
* returning the first successful conversion to utf8. If no
* conversion succeeds, return NULL.
*
* Callers must free the returned string if not NULL.
*
* This function is identical to mono_unicode_from_external, apart
* from returning utf8 not utf16; it's handy in a few places to work
* in utf8.
*/
gchar *mono_utf8_from_external (const gchar *in)
{
gchar *res=NULL;
gchar **encodings;
const gchar *encoding_list;
int i;
if(in==NULL) {
return(NULL);
}
encoding_list=g_getenv ("MONO_EXTERNAL_ENCODINGS");
if(encoding_list==NULL) {
encoding_list = "";
}
encodings=g_strsplit (encoding_list, ":", 0);
for(i=0;encodings[i]!=NULL; i++) {
/* "default_locale" is a special case encoding */
if(!strcmp (encodings[i], "default_locale")) {
res=g_locale_to_utf8 (in, -1, NULL, NULL, NULL);
if(res!=NULL && !g_utf8_validate (res, -1, NULL)) {
g_free (res);
res=NULL;
}
} else {
res=g_convert (in, -1, "UTF8", encodings[i], NULL,
NULL, NULL);
}
if(res!=NULL) {
g_strfreev (encodings);
return(res);
}
}
g_strfreev (encodings);
if(g_utf8_validate (in, -1, NULL)) {
return(g_strdup (in));
}
return(NULL);
}
