gchar *gfire_game_get_version_str()
{
time_t version = gfire_games_version;
struct tm *time_data = localtime(&version);
gchar *local_str = g_malloc(100 * sizeof(gchar));
strftime(local_str, 100, "%d %B %Y", time_data);
gchar *ret = g_locale_to_utf8(local_str, -1, NULL, NULL, NULL);
g_free(local_str);
if(!ret)
return g_strdup(_("Unknown"));
return ret;
}
gboolean
g_file_test (const gchar *filename,
GFileTest test)
{
gchar *utf8_filename = g_locale_to_utf8 (filename, -1, NULL, NULL, NULL);
gboolean retval;
if (utf8_filename == NULL)
return FALSE;
retval = g_file_test_utf8 (utf8_filename, test);
g_free (utf8_filename);
return retval;
}
gchar *
qof_formatted_time_to_utf8(const gchar *locale_string)
{
gchar *retval;
GError *error = NULL;
retval = g_locale_to_utf8(locale_string, -1, NULL, NULL, &error);
if (!retval)
{
g_warning("Could not convert '%s' to UTF-8: %s", locale_string,
error->message);
g_error_free(error);
}
return retval;
}
static char *
exif_string_to_utf8 (const char *exif_str)
{
char *utf8_str;
if (g_utf8_validate (exif_str, -1, NULL)) {
return g_strdup (exif_str);
}
utf8_str = g_locale_to_utf8 (exif_str, -1, NULL, NULL, NULL);
if (utf8_str != NULL) {
return utf8_str;
}
return eel_make_valid_utf8 (exif_str);
}
/* {{{ proto string Glib::localeToUtf8(string text)
Converts a string which is in the encoding used for strings in the current locale into a UTF-8 string.
*/
PHP_METHOD(Glib, localeToUtf8)
{
char *str_utf8, *locale;
int length;
GError *error = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &locale, &length) == FAILURE) {
return;
}
str_utf8 = g_locale_to_utf8((const gchar*)locale, length, NULL, NULL, &error);
if (php_glib_handle_gerror(&error TSRMLS_CC)) {
return;
}
RETURN_STRING(str_utf8, 1);
}
static gchar *
ogg_get_comment (vorbis_comment *vc,
const gchar *label)
{
gchar *tag;
gchar *utf_tag;
if (vc && (tag = vorbis_comment_query (vc, label, 0)) != NULL) {
utf_tag = g_locale_to_utf8 (tag, -1, NULL, NULL, NULL);
/*g_free (tag);*/
return utf_tag;
} else {
return NULL;
}
}
/*
Affichage boite de dialog "nouveau"
@params p_widget Elément ayant déclencher la fonction
@params user_data Données transmis au callback
*/
void cb_new_dialog(GtkWidget *p_widget, gpointer user_data){
GtkWidget *p_dialog = gtk_dialog_new_with_buttons("Nouveau",
GTK_WINDOW(widgetCallback.entry1),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
"Rentrer la grille manuellement",
GTK_RESPONSE_ACCEPT,
g_locale_to_utf8("Générer automatiquement", -1, NULL, NULL, NULL),
GTK_RESPONSE_REJECT,
NULL);
gtk_widget_show(p_dialog);
g_signal_connect_swapped(p_dialog, "response", G_CALLBACK(cb_new), p_dialog);
//Parametres inutilises
(void)p_widget;
}
void
_gtk_entry_set_locale_text (GtkEntry *entry,
const char *text)
{
char *utf8_text;
if (text == NULL)
return;
utf8_text = g_locale_to_utf8 (text, -1, NULL, NULL, NULL);
if (utf8_text != NULL)
gtk_entry_set_text (entry, utf8_text);
else
gtk_entry_set_text (entry, "");
g_free (utf8_text);
}
static int
StatHostTime(void)
{
int64 hostSecs;
int64 hostUsecs;
time_t sec;
char buf[256];
gchar *timeUtf8;
Backdoor_proto bp;
bp.in.cx.halfs.low = BDOOR_CMD_GETTIMEFULL;
Backdoor(&bp);
if (bp.out.ax.word == BDOOR_MAGIC) {
hostSecs = ((uint64)bp.out.si.word << 32) | bp.out.dx.word;
} else {
/* Falling back to older command. */
bp.in.cx.halfs.low = BDOOR_CMD_GETTIME;
Backdoor(&bp);
hostSecs = bp.out.ax.word;
}
hostUsecs = bp.out.bx.word;
if (hostSecs <= 0) {
ToolsCmd_PrintErr("%s",
SU_(stat.gettime.failed, "Unable to get host time.\n"));
return EX_TEMPFAIL;
}
sec = hostSecs + (hostUsecs / 1000000);
if (strftime(buf, sizeof buf, "%d %b %Y %H:%M:%S", localtime(&sec)) == 0) {
ToolsCmd_PrintErr("%s",
SU_(stat.formattime.failed, "Unable to format host time.\n"));
return EX_TEMPFAIL;
}
timeUtf8 = g_locale_to_utf8(buf, -1, NULL, NULL, NULL);
if (timeUtf8 == NULL) {
ToolsCmd_PrintErr("%s",
SU_(stat.formattime.failed, "Unable to format host time.\n"));
return EX_TEMPFAIL;
}
g_print("%s\n", timeUtf8);
g_free(timeUtf8);
return EXIT_SUCCESS;
}
void _init_keynodes_str()
{
gsize bytes_read = 0, bytes_written = 0;
sc_uint32 i = 0;
keynodes_str = g_new0(gchar*, SC_KEYNODE_COUNT);
keynodes_str[SC_KEYNODE_NREL_SYSTEM_IDENTIFIER] = g_locale_to_utf8("nrel_system_identifier", -1, &bytes_read, &bytes_written, 0);
// check for errors
for (i = 0; i < (sc_uint32)SC_KEYNODE_COUNT; ++i)
{
if (keynodes_str[(sc_keynode)i] == null_ptr)
g_error("Error to create string representation of keynode: %d", i);
}
}
GDir *
g_dir_open (const gchar *path,
guint flags,
GError **error)
{
gchar *utf8_path = g_locale_to_utf8 (path, -1, NULL, NULL, error);
GDir *retval;
if (utf8_path == NULL)
return NULL;
retval = g_dir_open_utf8 (utf8_path, flags, error);
g_free (utf8_path);
return retval;
}
static gchar *time_to_string_format (time_t t, const gchar *format)
{
gchar buf[PATH_MAX+1];
struct tm tm;
size_t size;
g_return_val_if_fail (format, NULL);
if (t)
{
localtime_r (&t, &tm);
size = strftime (buf, PATH_MAX, format, &tm);
buf[size] = 0;
return g_locale_to_utf8 (buf, -1, NULL, NULL, NULL);
}
return g_strdup ("--");
}
void
data_window_add(struct data_window *win, struct param_list *param, int count)
{
int i;
GtkCellRenderer *cell;
GtkTreeIter iter;
GtkListStore *liststore;
GType types[count];
gchar *utf8;
if (! win->treeview) {
win->treeview=gtk_tree_view_new();
gtk_tree_view_set_model (GTK_TREE_VIEW (win->treeview), NULL);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(win->scrolled_window),win->treeview);
gtk_widget_show_all(GTK_WIDGET(win->window));
/* add column names to treeview */
for(i=0;i<count;i++) {
cell=gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (win->treeview),-1,param[i].name,
cell,"text",i, NULL);
}
}
/* find data storage and create a new one if none is there */
if (gtk_tree_view_get_model(GTK_TREE_VIEW (win->treeview)) == NULL) {
for(i=0;i<count;i++) types[i]=G_TYPE_STRING;
liststore=gtk_list_store_newv(count,types);
gtk_tree_view_set_model (GTK_TREE_VIEW (win->treeview), GTK_TREE_MODEL(liststore));
}
else
liststore=GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW (win->treeview)));
gtk_list_store_append(liststore,&iter);
/* add data to data storage */
for(i=0;i<count;i++) {
utf8=g_locale_to_utf8(param[i].value,-1,NULL,NULL,NULL);
gtk_list_store_set(liststore,&iter,i,utf8,-1);
}
#if 0
g_signal_connect(G_OBJECT(win->clist), "click-column", G_CALLBACK(click_column), NULL);
g_signal_connect(G_OBJECT(win->clist), "select-row", G_CALLBACK(select_row), win);
#endif
}
/**
* 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);
}
static gchar *
validate_vcard_string(gchar * vcstr)
{
gchar * utf8res;
gsize b_written;
/* check if it's a utf8 clean string and return it in this case */
if (!vcstr || g_utf8_validate(vcstr, -1, NULL))
return vcstr;
/* try to convert from the user's locale setting */
utf8res = g_locale_to_utf8(vcstr, -1, NULL, &b_written, NULL);
if (!utf8res)
return vcstr;
g_free(vcstr);
return utf8res;
}
gboolean
g_file_get_contents (const gchar *filename,
gchar **contents,
gsize *length,
GError **error)
{
gchar *utf8_filename = g_locale_to_utf8 (filename, -1, NULL, NULL, error);
gboolean retval;
if (utf8_filename == NULL)
return FALSE;
retval = g_file_get_contents_utf8 (utf8_filename, contents, length, error);
g_free (utf8_filename);
return retval;
}
static VALUE
rbglib_m_locale_to_utf8(G_GNUC_UNUSED VALUE self, VALUE str)
{
GError *err = NULL;
VALUE s = Qnil;
gchar* ret;
gsize written;
StringValue(str);
ret = g_locale_to_utf8(RSTRING_PTR(str), RSTRING_LEN(str),
NULL, &written, &err);
if (err != NULL)
RAISE_GERROR(err);
s = rb_str_new(ret, written);
g_free(ret);
return s;
}
static char *
convert_with_fallback (const char *str, const char *fallback)
{
char *utf;
utf = g_locale_to_utf8 (str, -1, 0, 0, 0);
if (!utf)
{
/* this can happen if CHARSET envvar is set wrong */
/* maybe it's already utf8 (breakage!) */
if (!g_utf8_validate (str, -1, NULL))
utf = g_strdup (fallback);
else
utf = g_strdup (str);
}
return utf;
}
void open_error(GtkWidget *file_selection, FILE *file,
const gchar * message_format, const gchar* path)
{
if(file == NULL){
GtkWidget *dialog;
dialog = gtk_message_dialog_new(GTK_WINDOW(file_selection),
GTK_DIALOG_MODAL,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_OK,
message_format,
g_locale_to_utf8(
path, -1, NULL,
NULL, NULL));
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
return;
}
}
gchar *
_gdk_win32_key_to_string (LONG lParam)
{
char buf[100];
gchar *keyname_utf8;
if (GetKeyNameText (lParam, buf, sizeof (buf)) &&
(keyname_utf8 = g_locale_to_utf8 (buf, -1, NULL, NULL, NULL)) != NULL)
{
gchar *retval = static_printf ("%s", keyname_utf8);
g_free (keyname_utf8);
return retval;
}
return static_printf ("unk-%#lx", lParam);
}
char *locale_to_utf8(const char *loc_str)
{
if(NULL==loc_str)
return NULL;
gsize bytes_read;
gsize bytes_written;
GError *err=NULL;
gchar *str=NULL;
str=g_locale_to_utf8(loc_str, -1, &bytes_read, &bytes_written, &err);
if(NULL==str){
fprintf(stderr, _("Can not convert %s to utf8.\n"), loc_str);
fprintf(stderr, "%s\n", err->message);
g_error_free(err);
exit(EXIT_FAILURE);
}
return str;
}
gboolean CoreManager::io_input(GIOChannel *source, GIOCondition cond)
{
if (io_input_timeout_conn.connected())
io_input_timeout_conn.disconnect();
termkey_advisereadable(tk);
TermKeyKey key;
TermKeyResult ret;
while ((ret = termkey_getkey(tk, &key)) == TERMKEY_RES_KEY) {
if (key.type == TERMKEY_TYPE_UNICODE && !utf8) {
gsize bwritten;
GError *err = NULL;
char *utf8;
// convert data from user charset to UTF-8
if (!(utf8 = g_locale_to_utf8(key.utf8, -1, NULL, &bwritten, &err))) {
if (err) {
g_warning(_("Error converting input to UTF-8 (%s)."),
err->message);
g_error_free(err);
err = NULL;
}
else
g_warning(_("Error converting input to UTF-8."));
continue;
}
memcpy(key.utf8, utf8, bwritten + 1);
g_free(utf8);
key.code.codepoint = g_utf8_get_char(key.utf8);
}
ProcessInput(key);
}
if (ret == TERMKEY_RES_AGAIN) {
int wait = termkey_get_waittime(tk);
io_input_timeout_conn = TimeoutOnceConnect(sigc::mem_fun(this,
&CoreManager::io_input_timeout), wait);
}
return TRUE;
}
gpointer
vsimple_dialog(ESD_TYPE_E type, gint btn_mask, const gchar *msg_format, va_list ap)
{
gchar *vmessage;
gchar *message;
queued_message_t *queued_message;
GtkWidget *win;
GdkWindowState state = 0;
/* Format the message. */
vmessage = g_strdup_vprintf(msg_format, ap);
/* convert character encoding from locale to UTF8 (using iconv) */
message = g_locale_to_utf8(vmessage, -1, NULL, NULL, NULL);
g_free(vmessage);
if (top_level != NULL) {
state = gdk_window_get_state(top_level->window);
}
/* If we don't yet have a main window or it's iconified, don't show the
dialog. If showing up a dialog, while main window is iconified, program
will become unresponsive! */
if (top_level == NULL || state & GDK_WINDOW_STATE_ICONIFIED) {
queued_message = g_malloc(sizeof (queued_message_t));
queued_message->type = type;
queued_message->btn_mask = btn_mask;
queued_message->message = message;
message_queue = g_slist_append(message_queue, queued_message);
return NULL;
}
/*
* Do we have any queued up messages? If so, pop them up.
*/
display_queued_messages();
win = display_simple_dialog(type, btn_mask, message);
g_free(message);
return win;
}
// all output ends up through here
void FPrintf(int flag, char *buf)
{
#if defined(USE_XML)
xmlNodePtr node;
static qboolean bGotXML = qfalse;
char level[2];
#endif
printf("%s", buf);
#if defined(USE_XML)
// the following part is XML stuff only.. but maybe we don't want that message to go down the XML pipe?
if(flag == SYS_NOXML)
return;
// output an XML file of the run
// use the DOM interface to build a tree
/*
<message level='flag'>
message string
.. various nodes to describe corresponding geometry ..
</message>
*/
if(!bGotXML)
{
// initialize
doc = xmlNewDoc("1.0");
doc->children = xmlNewDocRawNode(doc, NULL, "q3map_feedback", NULL);
bGotXML = qtrue;
}
node = xmlNewNode(NULL, "message");
{
gchar *utf8 = g_locale_to_utf8(buf, -1, NULL, NULL, NULL);
xmlNodeSetContent(node, utf8);
g_free(utf8);
}
level[0] = (int)'0' + flag;
level[1] = 0;
xmlSetProp(node, "level", (char *)&level);
xml_SendNode(node);
#endif
}
static void
book_loaded_cb (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
ESource *source = E_SOURCE (source_object);
VCardImporter *gci = user_data;
EClient *client = NULL;
e_client_utils_open_new_finish (source, result, &client, NULL);
if (client == NULL) {
vcard_import_done (gci);
return;
}
gci->book_client = E_BOOK_CLIENT (client);
if (gci->encoding == VCARD_ENCODING_UTF16) {
gchar *tmp;
gunichar2 *contents_utf16 = (gunichar2 *) gci->contents;
tmp = utf16_to_utf8 (contents_utf16);
g_free (gci->contents);
gci->contents = tmp;
} else if (gci->encoding == VCARD_ENCODING_LOCALE) {
gchar *tmp;
tmp = g_locale_to_utf8 (gci->contents, -1, NULL, NULL, NULL);
g_free (gci->contents);
gci->contents = tmp;
}
gci->contactlist = eab_contact_list_from_string (gci->contents);
g_free (gci->contents);
gci->contents = NULL;
gci->iterator = gci->contactlist;
gci->total = g_slist_length (gci->contactlist);
if (gci->iterator)
gci->idle_id = g_idle_add (vcard_import_contacts, gci);
else
vcard_import_done (gci);
}
gchar *utf8_convert(const gchar *in) {
gsize rbytes, wbytes;
gchar *out;
GError *error = NULL;
g_return_val_if_fail(in, NULL);
out = g_locale_to_utf8(in, -1, &rbytes, &wbytes, &error);
if (out == NULL && error != NULL) {
if (g_utf8_validate(in, -1, NULL)) {
out = g_strdup(in);
} else {
g_printerr("g_locale_to_utf8 failed: %s\n", error->message);
out = NULL;
}
g_error_free(error);
}
return out;
}
sc_bool sc_helper_resolve_system_identifier(sc_memory_context const * ctx, const char *system_idtf, sc_addr *result)
{
gchar *keynode_idtf = 0;
gsize bytes_written = 0;
keynode_idtf = g_locale_to_utf8(system_idtf, -1, 0, &bytes_written, 0);
if (keynode_idtf == null_ptr)
{
g_warning("Error while trying to convert %s to utf-8", system_idtf);
return SC_FALSE;
}
if (sc_helper_find_element_by_system_identifier(ctx, keynode_idtf, (sc_uint32)bytes_written, result) != SC_RESULT_OK)
return SC_FALSE;
g_free(keynode_idtf);
return SC_TRUE;
}
static gchar *get_wm_info(void)
{
/* this code is taken from wmctrl utility, adapted
Copyright (C) 2003, Tomas Styblo <*****@*****.**> */
Display *disp;
Window *sup_window = NULL;
gchar *wm_name = NULL;
if (!(disp = XOpenDisplay(NULL))) {
fputs("Cannot open display.\n", stderr);
return NULL;
}
if (!(sup_window = (Window *)get_property(disp, DefaultRootWindow(disp),
XA_WINDOW, "_NET_SUPPORTING_WM_CHECK", NULL))) {
if (!(sup_window = (Window *)get_property(disp, DefaultRootWindow(disp),
XA_CARDINAL, "_WIN_SUPPORTING_WM_CHECK", NULL))) {
fputs("Cannot get window manager info properties.\n"
"(_NET_SUPPORTING_WM_CHECK or _WIN_SUPPORTING_WM_CHECK)\n", stderr);
return NULL;
}
}
/* WM_NAME */
if (!(wm_name = get_property(disp, *sup_window,
XInternAtom(disp, "UTF8_STRING", False), "_NET_WM_NAME", NULL))) {
if (!(wm_name = get_property(disp, *sup_window,
XA_STRING, "_NET_WM_NAME", NULL))) {
fputs("Cannot get name of the window manager (_NET_WM_NAME).\n", stderr);
} else {
gchar *_wm_name = wm_name;
wm_name = g_locale_to_utf8(_wm_name, -1, NULL, NULL, NULL);
if (wm_name)
g_free(_wm_name);
else
/* Cannot convert string from locale charset to UTF-8. */
wm_name = _wm_name;
}
}
return wm_name;
}
void context_output(int fd, const char *text, gint length)
{
static int last_fd = -1;
GtkTextIter end;
gchar *utf8;
gtk_text_buffer_get_end_iter(context, &end);
if (last_fd == 3 && fd != 0)
gtk_text_buffer_insert(context, &end, "\n", 1);
if (fd != last_fd)
last_fd = fd;
if (length == -1)
length = strlen(text);
dc_chars += length;
utf8 = g_locale_to_utf8(text, length, NULL, NULL, NULL);
if (utf8)
{
gtk_text_buffer_insert_with_tags(context, &end, utf8, -1, fd_tags[fd], NULL);
g_free(utf8);
}
else
gtk_text_buffer_insert_with_tags(context, &end, text, length, fd_tags[fd], NULL);
if (dc_chars > DC_LIMIT + (DC_DELTA / 2))
{
GtkTextIter start, delta;
gtk_text_buffer_get_start_iter(context, &start);
gtk_text_buffer_get_iter_at_offset(context, &delta, DC_DELTA);
gtk_text_buffer_delete(context, &start, &delta);
gtk_text_buffer_get_end_iter(context, &end);
dc_chars = gtk_text_buffer_get_char_count(context);
}
gtk_text_buffer_place_cursor(context, &end);
gtk_text_view_scroll_mark_onscreen(debug_context, gtk_text_buffer_get_insert(context));
}
gchar* get_time (const gchar* format)
{
gchar *out = NULL;
gchar *out_utf8 = NULL;
time_t clock;
struct tm *now;
size_t out_length = 0;
gchar *locale_format;
if (strlen (format) == 0)
return g_strdup (" ");
locale_format = g_locale_from_utf8 (format, -1, NULL, NULL, NULL);
if (! locale_format)
return g_strdup (" ");
clock = time (NULL);
now = localtime (&clock);
do
{
out_length += 255;
out = g_realloc (out, out_length);
}
while (strftime (out, out_length, locale_format, now) == 0);
g_free (locale_format);
if (g_utf8_validate (out, -1, NULL))
out_utf8 = out;
else
{
out_utf8 = g_locale_to_utf8 (out, -1, NULL, NULL, NULL);
g_free (out);
if (! out_utf8)
out_utf8 = g_strdup (" ");
}
return out_utf8;
}
