static GValue *
gdaui_entry_wrapper_get_value (GdauiDataEntry *iface)
{
GValue *value = NULL;
GdauiEntryWrapper *wrapper;
g_return_val_if_fail (GDAUI_IS_ENTRY_WRAPPER (iface), NULL);
wrapper = (GdauiEntryWrapper*) iface;
if (wrapper->priv->null_forced)
value = gda_value_new_null ();
else {
if (wrapper->priv->default_forced) {
if (G_VALUE_TYPE (wrapper->priv->value_default) == wrapper->priv->type)
value = gda_value_copy (wrapper->priv->value_default);
else
value = gda_value_new_null ();
}
else {
check_correct_init (wrapper);
value = (wrapper->priv->real_class->real_get_value) (wrapper);
}
}
return value;
}
/* Interface implementation */
static void
gdaui_entry_wrapper_set_value_type (GdauiDataEntry *iface, GType type)
{
GdauiEntryWrapper *wrapper;
g_return_if_fail (GDAUI_IS_ENTRY_WRAPPER (iface));
wrapper = (GdauiEntryWrapper*) iface;
if (wrapper->priv->type != type) {
GValue *value;
if (wrapper->priv->value_ref) {
gda_value_free (wrapper->priv->value_ref);
wrapper->priv->value_ref = NULL;
}
if (wrapper->priv->value_default) {
gda_value_free (wrapper->priv->value_default);
wrapper->priv->value_default = NULL;
}
wrapper->priv->type = type;
wrapper->priv->value_default = gda_value_new_null ();
/* Set original value */
value = gda_value_new_null ();
gdaui_entry_wrapper_set_ref_value (GDAUI_DATA_ENTRY (wrapper), value);
gda_value_free (value);
}
}
/* Returns: TRUE if FileRow value has been changed */
static gboolean
update_file_size (FileRow *row, const gchar *complete_filename)
{
struct stat filestat;
gboolean changed = TRUE;
if (! g_stat (complete_filename, &filestat)) {
if (row->size_value && (G_VALUE_TYPE (row->size_value) == G_TYPE_UINT)
&& (g_value_get_uint (row->size_value) == (guint)filestat.st_size))
changed = FALSE;
else {
if (row->size_value)
gda_value_free (row->size_value);
g_value_set_uint (row->size_value = gda_value_new (G_TYPE_UINT), filestat.st_size);
}
}
else {
if (row->size_value && gda_value_is_null (row->size_value))
changed = FALSE;
else {
if (row->size_value)
gda_value_free (row->size_value);
row->size_value = gda_value_new_null ();
}
}
return changed;
}
static void
gdaui_entry_wrapper_set_value_default (GdauiDataEntry *iface, const GValue *value)
{
GdauiEntryWrapper *wrapper;
g_return_if_fail (GDAUI_IS_ENTRY_WRAPPER (iface));
wrapper = (GdauiEntryWrapper*) iface;
if (wrapper->priv->value_default)
gda_value_free (wrapper->priv->value_default);
if (value)
wrapper->priv->value_default = gda_value_copy ((GValue *) value);
else
wrapper->priv->value_default = gda_value_new_null ();
if (wrapper->priv->default_forced) {
if (G_VALUE_TYPE (wrapper->priv->value_default) == wrapper->priv->type) {
check_correct_init (wrapper);
block_signals (wrapper);
gdaui_entry_wrapper_set_value (iface, wrapper->priv->value_default);
unblock_signals (wrapper);
wrapper->priv->default_forced = TRUE;
}
else {
check_correct_init (wrapper);
(*wrapper->priv->real_class->real_set_value) (wrapper, NULL);
}
gdaui_entry_wrapper_emit_signal (wrapper);
}
}
/* Returns: TRUE if FileRow value has been changed */
static gboolean
update_file_mime (FileRow *row, const gchar *complete_filename)
{
gboolean changed = TRUE;
GValue *value = NULL;
#ifdef HAVE_GIO
GFile *file;
GFileInfo *info;
file = g_file_new_for_path (complete_filename);
info = g_file_query_info (file,
G_FILE_ATTRIBUTE_STANDARD_FAST_CONTENT_TYPE,
G_FILE_QUERY_INFO_NONE, NULL, NULL);
if (info) {
value = gda_value_new (G_TYPE_STRING);
g_value_set_string (value, g_file_info_get_content_type (info));
g_object_unref (info);
}
else
value = gda_value_new_null ();
g_object_unref (file);
#else
value = gda_value_new_null ();
#endif
if (value) {
if (row->mime_value && (G_VALUE_TYPE (row->mime_value) == G_TYPE_STRING)
&& !gda_value_compare (row->mime_value, value))
changed = FALSE;
else {
if (row->mime_value)
gda_value_free (row->mime_value);
row->mime_value = value;
}
}
else {
if (row->mime_value && gda_value_is_null (row->mime_value))
changed = FALSE;
else {
if (row->mime_value)
gda_value_free (row->mime_value);
row->mime_value = gda_value_new_null ();
}
}
return changed;
}
/**
* gda_data_handler_get_value_from_sql:
* @dh: an object which implements the #GdaDataHandler interface
* @sql: (allow-none) (transfer none): an SQL string, or %NULL
* @type: a GType
*
* Creates a new GValue which represents the SQL value given as argument. This is
* the opposite of the function gda_data_handler_get_sql_from_value(). The type argument
* is used to determine the real data type requested for the returned value.
*
* If the @sql string is %NULL, then the returned GValue is of type GDA_TYPE_NULL;
* if the @sql string does not correspond to a valid SQL string for the requested type, then
* the %NULL is returned.
*
* Returns: (transfer full): the new #GValue or %NULL on error
*/
GValue *
gda_data_handler_get_value_from_sql (GdaDataHandler *dh, const gchar *sql, GType type)
{
g_return_val_if_fail (dh && GDA_IS_DATA_HANDLER (dh), NULL);
g_return_val_if_fail (_accepts_g_type (dh, type), NULL);
if (!sql)
return gda_value_new_null ();
if (GDA_DATA_HANDLER_GET_IFACE (dh)->get_value_from_sql)
return (GDA_DATA_HANDLER_GET_IFACE (dh)->get_value_from_sql) (dh, sql, type);
return NULL;
}
static void
gdaui_entry_wrapper_set_ref_value (GdauiDataEntry *iface, const GValue *value)
{
GdauiEntryWrapper *wrapper;
gboolean changed = TRUE;
GValue *evalue;
g_return_if_fail (GDAUI_IS_ENTRY_WRAPPER (iface));
wrapper = (GdauiEntryWrapper*) iface;
check_correct_init (wrapper);
/* compare existing value and the one provided as argument */
if (wrapper->priv->real_class->value_is_equal_to)
changed = ! wrapper->priv->real_class->value_is_equal_to (wrapper, value);
else {
evalue = gdaui_entry_wrapper_get_value (iface);
g_assert (evalue);
if ((!value || (G_VALUE_TYPE (value) == GDA_TYPE_NULL)) &&
(G_VALUE_TYPE (evalue) == GDA_TYPE_NULL))
changed = FALSE;
else if (!gda_value_differ ((GValue *) value, evalue))
changed = FALSE;
gda_value_free (evalue);
}
/* get rid on any existing orig value */
if (wrapper->priv->value_ref) {
gda_value_free (wrapper->priv->value_ref);
wrapper->priv->value_ref = NULL;
}
/* apply changes, if any */
if (changed) {
block_signals (wrapper);
gdaui_entry_wrapper_set_value (iface, value);
unblock_signals (wrapper);
}
if (value) {
g_return_if_fail ((G_VALUE_TYPE ((GValue *) value) == wrapper->priv->type) ||
(G_VALUE_TYPE ((GValue *) value) == GDA_TYPE_NULL));
wrapper->priv->value_ref = gda_value_copy ((GValue *) value);
}
else
wrapper->priv->value_ref = gda_value_new_null ();
/* signal changes if any */
if (changed)
gdaui_entry_wrapper_emit_signal (wrapper);
}
/**
* gda_data_handler_get_value_from_str:
* @dh: an object which implements the #GdaDataHandler interface
* @str: (allow-none) (transfer none): a string or %NULL
* @type: a GType
*
* Creates a new GValue which represents the @str value given as argument. This is
* the opposite of the function gda_data_handler_get_str_from_value(). The type argument
* is used to determine the real data type requested for the returned value.
*
* If the @str string is %NULL, then the returned GValue is of type GDA_TYPE_NULL;
* if the @str string does not correspond to a valid string for the requested type, then
* %NULL is returned.
*
* Note: the @str string must be in the current locale representation
*
* Returns: (transfer full): the new #GValue or %NULL on error
*/
GValue *
gda_data_handler_get_value_from_str (GdaDataHandler *dh, const gchar *str, GType type)
{
g_return_val_if_fail (dh && GDA_IS_DATA_HANDLER (dh), NULL);
g_return_val_if_fail (_accepts_g_type (dh, type), NULL);
if (!str)
return gda_value_new_null ();
if (GDA_DATA_HANDLER_GET_IFACE (dh)->get_value_from_str)
return (GDA_DATA_HANDLER_GET_IFACE (dh)->get_value_from_str) (dh, str, type);
else {
/* if the get_value_from_str() method is not implemented, then we try the
get_value_from_sql() method */
if (GDA_DATA_HANDLER_GET_IFACE (dh)->get_value_from_sql)
return (GDA_DATA_HANDLER_GET_IFACE (dh)->get_value_from_sql) (dh, str, type);
}
return NULL;
}
static GValue *
real_get_value (GdauiEntryWrapper *mgwrap)
{
GValue *value;
GdauiEntryString *mgstr;
GdaDataHandler *dh;
g_return_val_if_fail (GDAUI_IS_ENTRY_STRING (mgwrap), NULL);
mgstr = GDAUI_ENTRY_STRING (mgwrap);
GdauiEntryStringPrivate *priv = gdaui_entry_string_get_instance_private (mgstr);
dh = gdaui_data_entry_get_handler (GDAUI_DATA_ENTRY (mgwrap));
if (! priv->multiline) {
gchar *cstr;
cstr = gdaui_entry_get_text (GDAUI_ENTRY (priv->entry));
value = gda_data_handler_get_value_from_str (dh, cstr, gdaui_data_entry_get_value_type (GDAUI_DATA_ENTRY (mgwrap)));
g_free (cstr);
}
else {
GtkTextIter start, end;
gchar *str;
gtk_text_buffer_get_start_iter (priv->buffer, &start);
gtk_text_buffer_get_end_iter (priv->buffer, &end);
str = gtk_text_buffer_get_text (priv->buffer, &start, &end, FALSE);
value = gda_data_handler_get_value_from_str (dh, str, gdaui_data_entry_get_value_type (GDAUI_DATA_ENTRY (mgwrap)));
g_free (str);
}
if (!value) {
/* in case the gda_data_handler_get_value_from_str() returned an error because
the contents of the GtkEntry cannot be interpreted as a GValue */
value = gda_value_new_null ();
}
return value;
}
static gboolean
do_test (ATest *test)
{
GdaSqlParser *parser;
GdaStatement *stmt;
GError *error = NULL;
gchar *tmp;
g_print ("** test %s\n", test->id);
parser = gda_sql_parser_new ();
GdaSet *params;
GValue *nv;
GdaHolder *holder;
stmt = gda_sql_parser_parse_string (parser, test->sql, NULL, &error);
g_object_unref (parser);
if (!stmt) {
g_print ("Parsing error: %s\n", error && error->message ? error->message : "No detail");
return FALSE;
}
if (! gda_statement_get_parameters (stmt, ¶ms, &error)) {
g_print ("Error: %s\n", error && error->message ? error->message : "No detail");
return FALSE;
}
g_assert (gda_set_set_holder_value (params, NULL, "name", "zzz"));
nv = gda_value_new_null ();
holder = gda_set_get_holder (params, "id");
g_assert (gda_holder_set_value (holder, nv, NULL));
gda_value_free (nv);
GdaSqlStatement *sqlst;
g_object_get (stmt, "structure", &sqlst, NULL);
sqlst = gda_rewrite_sql_statement_for_null_parameters (sqlst, params, NULL, &error);
if (!sqlst) {
g_print ("Rewrite error: %s\n", error && error->message ? error->message : "No detail");
return FALSE;
}
g_object_set (stmt, "structure", sqlst, NULL);
/* SQL rendering */
tmp = gda_statement_to_sql_extended (stmt, NULL, NULL, GDA_STATEMENT_SQL_PARAMS_SHORT,
NULL, &error);
if (!tmp) {
g_print ("Rendering error: %s\n", error && error->message ? error->message : "No detail");
return FALSE;
}
/*g_print ("SQL after mod: [%s]\n", tmp);*/
g_free (tmp);
tmp = gda_sql_statement_serialize (sqlst);
if (!tmp) {
g_print ("Error: gda_sql_statement_serialize() failed\n");
return FALSE;
}
else if (strcmp (test->result, tmp)) {
g_print ("Exp: [%s]\nGot: [%s]\n", test->result, tmp);
return FALSE;
}
g_free (tmp);
gda_sql_statement_free (sqlst);
g_object_unref (stmt);
return TRUE;
}
/* Returns: TRUE if FileRow value has been changed */
static gboolean
update_file_md5sum (FileRow *row, const gchar *complete_filename)
{
gboolean changed = TRUE;
GValue *value = NULL;
/* MD5 computation */
MD5_CTX context;
unsigned char digest[16]; /* Flawfinder: ignore */
GString *md5str;
gint i;
int fd;
gpointer map;
guint length;
HANDLE view;
/* file mapping in mem */
length = g_value_get_uint (row->size_value);
if (length == 0)
goto md5end;
fd = open (complete_filename, O_RDONLY); /* Flawfinder: ignore */
if (fd < 0)
goto md5end;
#ifndef G_OS_WIN32
map = mmap (NULL, length, PROT_READ, MAP_PRIVATE, fd, 0);
if (map == MAP_FAILED) {
close (fd);
goto md5end;
}
#else
view = CreateFileMapping ((HANDLE) fd,
NULL, PAGE_READONLY|SEC_COMMIT, 0,0 , NULL);
if (!view) {
close (fd);
goto md5end;
}
map = MapViewOfFile (view, FILE_MAP_READ, 0, 0, length);
if (!map) {
close (fd);
goto md5end;
}
#endif /* !G_OS_WIN32 */
MD5Init (&context);
MD5Update (&context, map, length);
MD5Final (digest, &context);
md5str = g_string_new ("");
for (i = 0; i < 16; i++)
g_string_append_printf (md5str, "%02x", digest[i]);
value = gda_value_new (G_TYPE_STRING);
g_value_take_string (value, md5str->str);
g_string_free (md5str, FALSE);
#ifndef G_OS_WIN32
munmap (map, length);
#else
UnmapViewOfFile (map);
#endif /* !G_OS_WIN32 */
close (fd);
md5end:
if (value) {
if (row->md5sum_value && (G_VALUE_TYPE (row->md5sum_value) == G_TYPE_STRING)
&& !gda_value_compare (row->md5sum_value, value))
changed = FALSE;
else {
if (row->md5sum_value)
gda_value_free (row->md5sum_value);
row->md5sum_value = value;
}
}
else {
if (row->md5sum_value && gda_value_is_null (row->md5sum_value))
changed = FALSE;
else {
if (row->md5sum_value)
gda_value_free (row->md5sum_value);
row->md5sum_value = gda_value_new_null ();
}
}
return changed;
}
