SkkEncodingConverter* skk_encoding_converter_construct (GType object_type, const gchar* encoding, GError** error) {
SkkEncodingConverter * self = NULL;
const gchar* _tmp0_;
const gchar* _tmp1_;
GCharsetConverter* _tmp2_;
GCharsetConverter* _tmp3_;
const gchar* _tmp4_;
GCharsetConverter* _tmp5_;
GCharsetConverter* _tmp6_;
GError * _inner_error_ = NULL;
g_return_val_if_fail (encoding != NULL, NULL);
self = (SkkEncodingConverter*) g_object_new (object_type, NULL);
_tmp0_ = encoding;
skk_encoding_converter_set_encoding (self, _tmp0_);
_tmp1_ = encoding;
_tmp2_ = g_charset_converter_new (_tmp1_, SKK_ENCODING_CONVERTER_INTERNAL_ENCODING, &_inner_error_);
_tmp3_ = _tmp2_;
if (_inner_error_ != NULL) {
g_propagate_error (error, _inner_error_);
_g_object_unref0 (self);
return NULL;
}
_g_object_unref0 (self->priv->encoder);
self->priv->encoder = _tmp3_;
_tmp4_ = encoding;
_tmp5_ = g_charset_converter_new (SKK_ENCODING_CONVERTER_INTERNAL_ENCODING, _tmp4_, &_inner_error_);
_tmp6_ = _tmp5_;
if (_inner_error_ != NULL) {
g_propagate_error (error, _inner_error_);
_g_object_unref0 (self);
return NULL;
}
_g_object_unref0 (self->priv->decoder);
self->priv->decoder = _tmp6_;
return self;
}
static VALUE
rg_initialize(VALUE self, VALUE to, VALUE from)
{
GError *error = NULL;
GCharsetConverter *converter;
converter = g_charset_converter_new(RVAL2CSTR(to),
RVAL2CSTR(from),
&error);
if (converter == NULL)
rbgio_raise_error(error);
G_INITIALIZE(self, converter);
return Qnil;
}
static GCharsetConverter *
guess_encoding (GeditDocumentOutputStream *stream,
const void *inbuf,
gsize inbuf_size)
{
GCharsetConverter *conv = NULL;
if (inbuf == NULL || inbuf_size == 0)
{
stream->priv->is_utf8 = TRUE;
return NULL;
}
if (stream->priv->encodings != NULL &&
stream->priv->encodings->next == NULL)
{
stream->priv->use_first = TRUE;
}
/* We just check the first block */
while (TRUE)
{
const GeditEncoding *enc;
if (conv != NULL)
{
g_object_unref (conv);
conv = NULL;
}
/* We get an encoding from the list */
enc = get_encoding (stream);
/* if it is NULL we didn't guess anything */
if (enc == NULL)
{
break;
}
gedit_debug_message (DEBUG_UTILS, "trying charset: %s",
gedit_encoding_get_charset (stream->priv->current_encoding->data));
if (enc == gedit_encoding_get_utf8 ())
{
gsize remainder;
const gchar *end;
if (g_utf8_validate (inbuf, inbuf_size, &end) ||
stream->priv->use_first)
{
stream->priv->is_utf8 = TRUE;
break;
}
/* Check if the end is less than one char */
remainder = inbuf_size - (end - (gchar *)inbuf);
if (remainder < 6)
{
stream->priv->is_utf8 = TRUE;
break;
}
continue;
}
conv = g_charset_converter_new ("UTF-8",
gedit_encoding_get_charset (enc),
NULL);
/* If we tried all encodings we use the first one */
if (stream->priv->use_first)
{
break;
}
/* Try to convert */
if (try_convert (conv, inbuf, inbuf_size))
{
break;
}
}
if (conv != NULL)
{
g_converter_reset (G_CONVERTER (conv));
}
return conv;
}
bool TextFileSaver::step()
{
GOutputStream *stream = NULL;
// Open the file.
GFile *file = g_file_new_for_uri(uri());
GFileOutputStream *fileStream = g_file_replace(file,
NULL,
TRUE,
G_FILE_CREATE_NONE,
NULL,
&m_error);
if (!fileStream)
{
g_object_unref(file);
return true;
}
// Open the encoding converter and setup the input stream.
if (m_encoding == "UTF-8")
stream = G_OUTPUT_STREAM(fileStream);
else
{
GCharsetConverter *encodingConverter =
g_charset_converter_new(m_encoding.c_str(), "UTF-8", &m_error);
if (!encodingConverter)
{
g_object_unref(file);
g_object_unref(fileStream);
return true;
}
stream =
g_converter_output_stream_new(G_OUTPUT_STREAM(fileStream),
G_CONVERTER(encodingConverter));
g_object_unref(fileStream);
g_object_unref(encodingConverter);
}
// Convert and write.
int size =
g_output_stream_write(stream,
m_text.get(),
m_length == -1 ? strlen(m_text.get()) : m_length,
NULL,
&m_error);
if (size == -1)
{
g_object_unref(file);
g_object_unref(stream);
return true;
}
if (!g_output_stream_close(stream, NULL, &m_error))
{
g_object_unref(file);
g_object_unref(stream);
return true;
}
g_object_unref(stream);
// Get the time when the file was last modified.
GFileInfo *fileInfo;
fileInfo =
g_file_query_info(file,
G_FILE_ATTRIBUTE_TIME_MODIFIED,
G_FILE_QUERY_INFO_NONE,
NULL,
&m_error);
if (!fileInfo)
{
g_object_unref(file);
return true;
}
m_modifiedTime.seconds = g_file_info_get_attribute_uint64(
fileInfo,
G_FILE_ATTRIBUTE_TIME_MODIFIED);
g_object_unref(fileInfo);
fileInfo =
g_file_query_info(file,
G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC,
G_FILE_QUERY_INFO_NONE,
NULL,
&m_error);
if (!fileInfo)
{
g_object_unref(file);
return true;
}
m_modifiedTime.microSeconds = g_file_info_get_attribute_uint32(
fileInfo,
G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC);
g_object_unref(fileInfo);
g_object_unref(file);
return true;
}
static gboolean
_gtr_po_load_ensure_utf8 (GtrPo * po, GError ** error)
{
GMappedFile *mapped;
const gchar *content;
gboolean utf8_valid;
gchar *filename;
gsize size;
GtrPoPrivate *priv = gtr_po_get_instance_private (po);
filename = g_file_get_path (priv->location);
mapped = g_mapped_file_new (filename, FALSE, error);
g_free (filename);
if (!mapped)
return FALSE;
content = g_mapped_file_get_contents (mapped);
size = g_mapped_file_get_length (mapped);
utf8_valid = g_utf8_validate (content, size, NULL);
if (!_gtr_po_load (po, priv->location, error))
{
g_mapped_file_unref (mapped);
return FALSE;
}
if (!utf8_valid &&
priv->header)
{
gchar *charset = NULL;
if (priv->header)
charset = gtr_header_get_charset (priv->header);
if (charset && *charset && strcmp (charset, "UTF-8") != 0)
{
GOutputStream *converter_stream, *stream;
GCharsetConverter *converter;
GIOStream *iostream;
GFile *tmp;
/* Store UTF-8 converted file in $TMP */
converter = g_charset_converter_new ("UTF-8", charset, NULL);
if (!converter)
{
g_set_error (error,
GTR_PO_ERROR,
GTR_PO_ERROR_ENCODING,
_("Could not convert from charset “%s” to UTF-8"),
charset);
g_mapped_file_unref (mapped);
g_free (charset);
return FALSE;
}
g_free (charset);
tmp = g_file_new_tmp ("gtranslator-XXXXXX.po",
(GFileIOStream **) &iostream,
NULL);
if (!tmp)
{
g_set_error (error,
GTR_PO_ERROR,
GTR_PO_ERROR_ENCODING,
_("Could not store temporary "
"file for encoding conversion"));
g_mapped_file_unref (mapped);
g_object_unref (converter);
return FALSE;
}
stream = g_io_stream_get_output_stream (iostream);
converter_stream =
g_converter_output_stream_new (stream,
G_CONVERTER (converter));
if (!g_output_stream_write_all (converter_stream,
content, size, NULL,
NULL, NULL))
{
g_set_error (error,
GTR_PO_ERROR,
GTR_PO_ERROR_ENCODING,
_("Could not store temporary "
"file for encoding conversion"));
g_object_unref (converter_stream);
g_object_unref (iostream);
g_object_unref (converter);
g_mapped_file_unref (mapped);
return FALSE;
}
g_object_unref (converter_stream);
g_object_unref (iostream);
g_object_unref (converter);
/* Now load again the converted file */
if (!_gtr_po_load (po, tmp, error))
{
g_mapped_file_unref (mapped);
return FALSE;
}
/* Ensure Content-Type is set correctly
* in the header as per the content
*/
if (priv->header)
gtr_header_set_charset (priv->header, "UTF-8");
utf8_valid = TRUE;
}
}
g_mapped_file_unref (mapped);
if (!utf8_valid)
{
g_set_error (error,
GTR_PO_ERROR,
GTR_PO_ERROR_ENCODING,
_("All attempt to convert the file to UTF-8 has failed, "
"use the msgconv or iconv command line tools before "
"opening this file with GNOME Translation Editor"));
return FALSE;
}
return TRUE;
}
void TextCodecGtk::createIConvEncoder() const
{
ASSERT(!m_iconvEncoder);
m_iconvEncoder = adoptGRef(g_charset_converter_new(m_encoding.name(), internalEncodingName, 0));
}
