static void
gdaui_entry_wrapper_set_property (GObject *object,
guint param_id,
const GValue *value,
GParamSpec *pspec)
{
GdauiEntryWrapper *wrapper = GDAUI_ENTRY_WRAPPER (object);
if (wrapper->priv) {
switch (param_id) {
case PROP_SET_DEFAULT_IF_INVALID: {
guint attrs;
wrapper->priv->set_default_if_invalid = g_value_get_boolean (value);
attrs = gdaui_data_entry_get_attributes (GDAUI_DATA_ENTRY (wrapper));
if (wrapper->priv->set_default_if_invalid && (attrs & GDA_VALUE_ATTR_DATA_NON_VALID)) {
GValue *sane_value;
GdaDataHandler *dh;
GType type;
check_correct_init (wrapper);
dh = gdaui_data_entry_get_handler (GDAUI_DATA_ENTRY (wrapper));
type = gdaui_data_entry_get_value_type (GDAUI_DATA_ENTRY (wrapper));
sane_value = gda_data_handler_get_sane_init_value (dh, type);
(*wrapper->priv->real_class->real_set_value) (wrapper, sane_value);
if (sane_value)
gda_value_free (sane_value);
}
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
break;
}
}
}
}
/*
* COMMAND: <gda_report_if>
*
* Creates a copy of the children of the <gda_report_if_true> or <gda_report_if_false> nodes depending on the
* result of the execution of the expression
*
* uses node's contents: yes
* requested attributes: none
*/
static gboolean
command_gda_report_if (GdaReportEngine *engine, xmlNodePtr node, GSList **created_nodes,
RunContext *context, GError **error)
{
GValue *value;
gboolean expr_is_true = FALSE;
xmlChar *prop;
prop = xmlGetProp (node, BAD_CAST "expr");
if (!prop) {
g_set_error (error, 0, 0, "%s",
_("No expression specified"));
return FALSE;
}
/* evaluate expression as boolean */
value = evaluate_expression (engine, context,
(const gchar *) prop, error);
if (!value)
return FALSE;
xmlFree (prop);
if (value && !gda_value_is_null (value)) {
if (G_VALUE_TYPE (value) == G_TYPE_BOOLEAN)
expr_is_true = g_value_get_boolean (value);
else {
GValue *trans;
trans = gda_value_new (G_TYPE_BOOLEAN);
if (g_value_transform (value, trans)) {
expr_is_true = g_value_get_boolean (trans);
gda_value_free (trans);
}
else {
gda_value_free (trans);
g_set_error (error, 0, 0,
_("Cannot cast value from type '%s' to type '%s'"),
g_type_name (G_VALUE_TYPE (value)), g_type_name (G_TYPE_BOOLEAN));
return FALSE;
}
}
gda_value_free (value);
}
/*g_print ("IF Expression evaluates to %d\n", expr_is_true);*/
/* find the correct sub node: <gda_report_if_true> or <gda_report_if_false> */
gchar *sub_node_name;
xmlNodePtr sub_node;
sub_node_name = expr_is_true ? "gda_report_if_true" : "gda_report_if_false";
for (sub_node = node->children; sub_node; sub_node = sub_node->next) {
if (!strcmp ((gchar *) sub_node->name, sub_node_name)) {
if (!real_run_at_node (engine, sub_node->children, context, error))
return FALSE;
else {
xmlNodePtr child;
for (child = sub_node->children; child; child = sub_node->children) {
xmlUnlinkNode (child);
*created_nodes = g_slist_prepend (*created_nodes, child);
}
}
}
}
*created_nodes = g_slist_reverse (*created_nodes);
return TRUE;
}
static GSList *
gda_tree_mgr_xml_update_children (GdaTreeManager *manager, GdaTreeNode *node,
G_GNUC_UNUSED const GSList *children_nodes,
gboolean *out_error, GError **error)
{
GdaTreeMgrXml *mgr = GDA_TREE_MGR_XML (manager);
GSList *list = NULL;
xmlNodePtr xnode, child;
const GValue *cvalue;
cvalue = gda_tree_node_get_node_attribute (node, "xmlnode");
if (cvalue)
xnode = (xmlNodePtr) g_value_get_pointer (cvalue);
else
xnode = mgr->priv->root;
for (child = xnode->children; child; child = child->next) {
GString *string = NULL;
if (mgr->priv->attributes) {
gint i;
for (i = 0; ; i++) {
xmlChar *prop;
if (! mgr->priv->attributes[i])
break;
prop = xmlGetProp (child, BAD_CAST mgr->priv->attributes[i]);
if (!prop)
continue;
if (!string)
string = g_string_new ("");
else
g_string_append_c (string, ' ');
g_string_append_printf (string, "[%s=%s]", mgr->priv->attributes[i],
(gchar*) prop);
xmlFree (prop);
}
}
else {
/* use all attributes */
xmlAttrPtr attr;
for (attr = child->properties; attr; attr = attr->next) {
xmlChar *prop;
prop = xmlGetProp (child, attr->name);
if (!prop)
continue;
if (!string)
string = g_string_new ("");
else
g_string_append_c (string, ' ');
g_string_append_printf (string, "[%s=%s]", (gchar*) attr->name, (gchar*) prop);
xmlFree (prop);
}
}
if (string) {
GValue *xvalue;
GdaTreeNode* snode;
snode = gda_tree_manager_create_node (manager, node, string->str);
g_string_free (string, TRUE);
g_value_set_pointer ((xvalue = gda_value_new (G_TYPE_POINTER)), child);
gda_tree_node_set_node_attribute (snode, "xmlnode", xvalue, NULL);
gda_value_free (xvalue);
list = g_slist_prepend (list, snode);
}
}
return list;
}
static void
set_preview_widget (TablePreferences *tpref)
{
GtkWidget *preview = NULL;
GtkTreeIter iter;
if (!tpref->priv->current_column)
return;
if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (tpref->priv->plugins_combo), &iter)) {
GdauiPlugin *plugin;
GtkTreeModel *model;
GType gtype;
gtype = tpref->priv->current_column->gtype;
model = tpref->priv->plugins_model;
gtk_tree_model_get (model, &iter, PL_COLUMN_PLUGIN, &plugin, -1);
if (plugin) {
GString *string = NULL;
if (tpref->priv->options_wid) {
GdaSet *plist;
GSList *list;
plist = gdaui_basic_form_get_data_set (GDAUI_BASIC_FORM (tpref->priv->options_wid));
for (list = plist->holders; list; list = list->next) {
GdaHolder *holder;
holder = GDA_HOLDER (list->data);
if (gda_holder_is_valid (holder)) {
const GValue *cvalue;
cvalue = gda_holder_get_value (holder);
if (cvalue && (G_VALUE_TYPE (cvalue) != GDA_TYPE_NULL)) {
gchar *str = gda_value_stringify (cvalue);
gchar *r1, *r2;
if (!string)
string = g_string_new ("");
else
g_string_append_c (string, ';');
r1 = gda_rfc1738_encode (gda_holder_get_id (holder));
r2 = gda_rfc1738_encode (str);
g_free (str);
g_string_append_printf (string, "%s=%s", r1, r2);
g_free (r1);
g_free (r2);
}
}
}
}
if (string) {
g_string_prepend_c (string, ':');
g_string_prepend (string, plugin->plugin_name);
preview = GTK_WIDGET (gdaui_new_data_entry (gtype, string->str));
g_string_free (string, TRUE);
}
else
preview = GTK_WIDGET (gdaui_new_data_entry (gtype, plugin->plugin_name));
}
else
preview = GTK_WIDGET (gdaui_new_data_entry (gtype, NULL));
}
GValue *prev_value = NULL;
if (tpref->priv->preview_wid) {
prev_value = gdaui_data_entry_get_value (GDAUI_DATA_ENTRY (tpref->priv->preview_wid));
gtk_widget_destroy (tpref->priv->preview_wid);
gtk_widget_show (tpref->priv->preview_none);
tpref->priv->preview_wid = NULL;
}
if (preview) {
if (prev_value &&
(G_VALUE_TYPE (prev_value) == gdaui_data_entry_get_value_type (GDAUI_DATA_ENTRY (preview))))
gdaui_data_entry_set_value (GDAUI_DATA_ENTRY (preview), prev_value);
gdaui_data_entry_set_attributes (GDAUI_DATA_ENTRY (preview),
0, GDA_VALUE_ATTR_ACTIONS_SHOWN);
tpref->priv->preview_wid = preview;
gtk_box_pack_start (GTK_BOX (tpref->priv->preview_vbox), preview, TRUE, TRUE, 0);
gtk_widget_hide (tpref->priv->preview_none);
gtk_widget_show (tpref->priv->preview_wid);
}
if (prev_value)
gda_value_free (prev_value);
}
GtkWidget *
do_form_pict (GtkWidget *do_widget)
{
if (!window) {
GdaStatement *stmt;
GtkWidget *vbox;
GtkWidget *label;
GdaDataModel *model;
GtkWidget *form;
GdaSet *data_set;
GdaHolder *param;
GValue *value;
window = gtk_dialog_new_with_buttons ("Form with the 'picture' plugin",
GTK_WINDOW (do_widget),
0,
GTK_STOCK_CLOSE,
GTK_RESPONSE_NONE,
NULL);
g_signal_connect (window, "response",
G_CALLBACK (gtk_widget_destroy), NULL);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (window))),
vbox, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
label = gtk_label_new ("The following GdauiForm widget displays data from the 'pictures' table.\n\n"
"The pictures are stored as BLOB inside the database and\n"
"are displayed using the 'picture' plugin (right click to \n"
"open a menu, or double click to load an image).");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
/* Create the demo widget */
stmt = gda_sql_parser_parse_string (demo_parser, "SELECT id, pict FROM pictures", NULL, NULL);
model = gda_connection_statement_execute_select (demo_cnc, stmt, NULL, NULL);
g_object_unref (stmt);
gda_data_select_compute_modification_statements (GDA_DATA_SELECT (model), NULL);
form = gdaui_form_new (model);
g_object_unref (model);
g_object_set (G_OBJECT (form), "info-flags",
GDAUI_DATA_PROXY_INFO_CURRENT_ROW |
GDAUI_DATA_PROXY_INFO_ROW_MOVE_BUTTONS |
GDAUI_DATA_PROXY_INFO_ROW_MODIFY_BUTTONS, NULL);
/* specify that we want to use the 'picture' plugin */
data_set = GDA_SET (gdaui_data_selector_get_data_set (GDAUI_DATA_SELECTOR (form)));
param = gda_set_get_holder (data_set, "pict");
value = gda_value_new_from_string ("picture", G_TYPE_STRING);
gda_holder_set_attribute_static (param, GDAUI_ATTRIBUTE_PLUGIN, value);
gda_value_free (value);
gtk_box_pack_start (GTK_BOX (vbox), form, TRUE, TRUE, 0);
}
gboolean visible;
g_object_get (G_OBJECT (window), "visible", &visible, NULL);
if (!visible)
gtk_widget_show_all (window);
else {
gtk_widget_destroy (window);
window = NULL;
}
return window;
}
/**
* filter_editor_new:
*
* Returns: a new #GtkWidget
*/
GtkWidget *
filter_editor_new (TConnection *tcnc)
{
FilterEditor *feditor;
GtkWidget *grid, *label, *entry;
GdaDataModel *model;
GList *values;
GValue *v1, *v2;
g_return_val_if_fail (T_IS_CONNECTION (tcnc), NULL);
feditor = FILTER_EDITOR (g_object_new (FILTER_EDITOR_TYPE, NULL));
feditor->priv->tcnc = g_object_ref ((GObject*) tcnc);
grid = gtk_grid_new ();
gtk_grid_set_column_spacing (GTK_GRID (grid), 5);
gtk_box_pack_start (GTK_BOX (feditor), grid, TRUE, TRUE, 0);
label = gtk_label_new (_("Base DN:"));
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_grid_attach (GTK_GRID (grid), label, 0, 0, 1, 1);
label = gtk_label_new (_("Filter expression:"));
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_grid_attach (GTK_GRID (grid), label, 0, 1, 1, 1);
label = gtk_label_new (_("Attributes to fetch:"));
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_grid_attach (GTK_GRID (grid), label, 0, 2, 1, 1);
label = gtk_label_new (_("Search scope:"));
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_grid_attach (GTK_GRID (grid), label, 0, 3, 1, 1);
entry = gtk_entry_new ();
gtk_widget_set_hexpand (entry, TRUE);
gtk_grid_attach (GTK_GRID (grid), entry, 1, 0, 1, 1);
feditor->priv->base_dn = entry;
g_signal_connect (entry, "activate",
G_CALLBACK (activated_cb), feditor);
entry = gtk_entry_new ();
gtk_widget_set_hexpand (entry, TRUE);
gtk_grid_attach (GTK_GRID (grid), entry, 1, 1, 1, 1);
feditor->priv->filter = entry;
g_signal_connect (entry, "activate",
G_CALLBACK (activated_cb), feditor);
entry = gtk_entry_new ();
gtk_widget_set_hexpand (entry, TRUE);
gtk_grid_attach (GTK_GRID (grid), entry, 1, 2, 1, 1);
feditor->priv->attributes = entry;
g_signal_connect (entry, "activate",
G_CALLBACK (activated_cb), feditor);
model = gda_data_model_array_new_with_g_types (2, G_TYPE_INT, G_TYPE_STRING);
g_value_set_string ((v1 = gda_value_new (G_TYPE_STRING)), "Base (search the base DN only)");
values = g_list_prepend (NULL, v1);
g_value_set_int ((v2 = gda_value_new (G_TYPE_INT)), GDA_LDAP_SEARCH_BASE);
values = g_list_prepend (values, v2);
g_assert (gda_data_model_append_values (model, values, NULL) >= 0);
gda_value_free (v1);
gda_value_free (v2);
g_value_set_string ((v1 = gda_value_new (G_TYPE_STRING)), "Onelevel (search immediate children of base DN only)");
values = g_list_prepend (NULL, v1);
g_value_set_int ((v2 = gda_value_new (G_TYPE_INT)), GDA_LDAP_SEARCH_ONELEVEL);
values = g_list_prepend (values, v2);
g_assert (gda_data_model_append_values (model, values, NULL) >= 0);
gda_value_free (v1);
gda_value_free (v2);
g_value_set_string ((v1 = gda_value_new (G_TYPE_STRING)), "Subtree (search of the base DN and the entire subtree below)");
values = g_list_prepend (NULL, v1);
g_value_set_int ((v2 = gda_value_new (G_TYPE_INT)), GDA_LDAP_SEARCH_SUBTREE);
values = g_list_prepend (values, v2);
g_assert (gda_data_model_append_values (model, values, NULL) >= 0);
gda_value_free (v1);
gda_value_free (v2);
gint cols[] = {1};
entry = gdaui_combo_new_with_model (model, 1, cols);
gtk_widget_set_hexpand (entry, TRUE);
g_object_unref (model);
gtk_grid_attach (GTK_GRID (grid), entry, 1, 3, 1, 1);
feditor->priv->scope = entry;
filter_editor_clear (feditor);
gtk_widget_show_all (grid);
return (GtkWidget*) feditor;
}
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;
}
static gboolean
gda_data_model_dir_set_values (GdaDataModel *model, gint row, GList *values, GError **error)
{
GdaDataModelDir *imodel;
GList *list;
gint col;
FileRow *frow;
gboolean has_changed = FALSE;
g_return_val_if_fail (GDA_IS_DATA_MODEL_DIR (model), FALSE);
g_return_val_if_fail (row >= 0, FALSE);
imodel = (GdaDataModelDir *) model;
g_return_val_if_fail (imodel->priv, FALSE);
if (!values)
return TRUE;
if ((guint)row >= imodel->priv->rows->len) {
gchar *str;
if (imodel->priv->rows->len > 0)
str = g_strdup_printf (_("Row %d out of range (0-%d)"), row,
imodel->priv->rows->len - 1);
else
str = g_strdup_printf (_("Row %d not found (empty data model)"), row);
add_error (imodel, str);
g_set_error (error, GDA_DATA_MODEL_ERROR, GDA_DATA_MODEL_ROW_OUT_OF_RANGE_ERROR,
"%s", str);
g_free (str);
return FALSE;
}
frow = g_ptr_array_index (imodel->priv->rows, row);
for (col = 0, list = values; list; list = list->next, col++) {
GValue *value = (GValue *) list->data;
const GValue *cvalue = gda_data_model_get_value_at (model, col, row, error);
if (!cvalue)
return FALSE;
if (!value || !gda_value_compare (value, cvalue))
continue;
switch (col) {
case COL_SIZE:
case COL_MIME:
case COL_MD5SUM:
default:
add_error (imodel, _("Column cannot be modified"));
g_set_error (error, GDA_DATA_MODEL_ERROR, GDA_DATA_MODEL_ACCESS_ERROR,
"%s", _("Column cannot be modified"));
return FALSE;
case COL_DIRNAME: {
/* check that the new dir still starts with the basedir */
const gchar *new_path;
gchar *old_path;
gint len, base_len;
new_path = value ? g_value_get_string (value) : "";
len = strlen (new_path);
base_len = strlen (imodel->priv->basedir);
if ((len < base_len) ||
(strncmp (new_path, imodel->priv->basedir, base_len))) {
add_error (imodel,
_("New path must be a subpath of the base directory"));
g_set_error (error, GDA_DATA_MODEL_ERROR, GDA_DATA_MODEL_ACCESS_ERROR,
"%s",
_("New path must be a subpath of the base directory"));
return FALSE;
}
old_path = compute_dirname (imodel, frow);
if (dir_equal (new_path, old_path)) {
g_free (old_path);
g_print ("Paths are equal...\n");
break;
}
if (!g_mkdir_with_parents (new_path, 0755)) {
gchar *new_filename;
GMappedFile *old_file;
gboolean allok = FALSE;
gchar *filename;
new_filename = g_build_filename (new_path,
frow->raw_filename_value ? frow->raw_filename_value :
g_value_get_string (frow->filename_value), NULL);
filename = compute_filename (imodel, frow);
old_file = g_mapped_file_new (filename, FALSE, NULL);
if (old_file) {
if (g_file_set_contents (new_filename, g_mapped_file_get_contents (old_file),
g_mapped_file_get_length (old_file), NULL)) {
g_unlink (filename);
allok = TRUE;
if (frow->data_value) {
GdaBlob *blob;
blob = (GdaBlob *) gda_value_get_blob (frow->data_value);
if (blob && blob->op)
_gda_dir_blob_set_filename (GDA_DIR_BLOB_OP (blob->op),
new_filename);
}
}
g_mapped_file_unref (old_file);
}
if (!allok) {
gchar *str;
str = g_strdup_printf (_("Could not rename file '%s' to '%s'"),
filename, new_filename);
add_error (imodel, str);
g_set_error (error,
GDA_DATA_MODEL_ERROR, GDA_DATA_MODEL_ACCESS_ERROR,
"%s", str);
g_free (str);
g_free (new_filename);
g_free (filename);
g_free (old_path);
return FALSE;
}
else {
/* renaming succeeded => update FileRow */
#ifndef G_OS_WIN32
g_rmdir (old_path);
#endif
g_free (frow->reldir);
frow->reldir = g_strdup (new_path + base_len);
}
g_free (filename);
g_free (new_filename);
has_changed = TRUE;
}
else {
gchar *str;
str = g_strdup_printf (_("Could not create directory '%s'"), new_path);
add_error (imodel, str);
g_set_error (error, GDA_DATA_MODEL_ERROR, GDA_DATA_MODEL_ACCESS_ERROR,
"%s", str);
g_free (str);
g_free (old_path);
return FALSE;
}
g_free (old_path);
break;
}
case COL_FILENAME: {
gchar *new_filename;
gchar *filename;
new_filename = g_build_filename (imodel->priv->basedir,
frow->reldir,
g_value_get_string (value), NULL);
filename = compute_filename (imodel, frow);
if (g_rename (filename, new_filename)) {
gchar *str;
str = g_strdup_printf (_("Could not rename file '%s' to '%s'"), filename, new_filename);
add_error (imodel, str);
g_set_error (error, GDA_DATA_MODEL_ERROR, GDA_DATA_MODEL_ACCESS_ERROR,
"%s", str);
g_free (str);
g_free (new_filename);
g_free (filename);
return FALSE;
}
else {
/* renaming succeeded => update FileRow */
gda_value_free (frow->filename_value);
frow->filename_value = gda_value_copy (value);
if (frow->raw_filename_value) {
g_free (frow->raw_filename_value);
frow->raw_filename_value = g_strdup (g_value_get_string (value));
}
if (frow->data_value) {
GdaBlob *blob;
blob = (GdaBlob *) gda_value_get_blob (frow->data_value);
if (blob && blob->op)
_gda_dir_blob_set_filename (GDA_DIR_BLOB_OP (blob->op),
new_filename);
}
}
g_free (new_filename);
g_free (filename);
has_changed = TRUE;
break;
}
case COL_DATA: {
GdaBlob *blob = NULL;
if (gda_value_isa (value, GDA_TYPE_BLOB)) {
blob = (GdaBlob *) gda_value_get_blob (value);
}
else if (gda_value_isa (value, GDA_TYPE_BINARY)) {
blob = (GdaBlob *) gda_value_get_binary (value);
}
else if (gda_value_is_null (value)) {
/* create a new empty blob */
blob = g_new0 (GdaBlob, 1);
}
if (blob) {
GdaBlobOp *op;
gchar *filename;
filename = compute_filename (imodel, frow);
op = _gda_dir_blob_op_new (filename);
if (gda_blob_op_write_all (op, blob) < 0) {
gchar *str;
str = g_strdup_printf (_("Could not overwrite contents of file '%s'"), filename);
add_error (imodel, str);
g_set_error (error, GDA_DATA_MODEL_ERROR,
GDA_DATA_MODEL_ACCESS_ERROR,
"%s", str);
g_free (str);
g_object_unref (op);
g_free (filename);
return FALSE;
}
g_object_unref (op);
if (gda_value_is_null (value))
g_free (blob);
has_changed = FALSE;
has_changed = update_file_size (frow, filename);
has_changed = update_file_md5sum (frow, filename) || has_changed;
has_changed = update_file_mime (frow, filename) || has_changed;
g_free (filename);
}
else {
add_error (imodel, _("Wrong type of data"));
g_set_error (error, GDA_DATA_MODEL_ERROR, GDA_DATA_MODEL_ACCESS_ERROR,
"%s", _("Wrong type of data"));
return FALSE;
}
break;
}
}
}
if (has_changed)
/* signal changes to data model */
gda_data_model_row_updated ((GdaDataModel *) model, row);
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;
}
static GSList *
mgr_columns_update_children (GdaTreeManager *manager, GdaTreeNode *node, const GSList *children_nodes,
gboolean *out_error, GError **error)
{
MgrColumns *mgr = MGR_COLUMNS (manager);
GSList *nodes_list = NULL;
GHashTable *ehash = NULL;
if (out_error)
*out_error = FALSE;
if (children_nodes)
ehash = hash_for_existing_nodes (children_nodes);
GdaMetaStruct *mstruct;
mstruct = t_connection_get_meta_struct (mgr->priv->tcnc);
if (!mstruct) {
g_set_error (error, MGR_COLUMNS_ERROR, MGR_COLUMNS_NO_META_STRUCT,
"%s", _("Not ready"));
if (out_error)
*out_error = TRUE;
return NULL;
}
GdaMetaDbObject *dbo;
GValue *schema_v = NULL, *name_v;
if (mgr->priv->schema)
g_value_set_string ((schema_v = gda_value_new (G_TYPE_STRING)), mgr->priv->schema);
g_value_set_string ((name_v = gda_value_new (G_TYPE_STRING)), mgr->priv->table_name);
dbo = gda_meta_struct_get_db_object (mstruct, NULL, schema_v, name_v);
if (schema_v)
gda_value_free (schema_v);
gda_value_free (name_v);
if (!dbo) {
g_set_error (error, MGR_COLUMNS_ERROR, MGR_COLUMNS_TABLE_NOT_FOUND,
"%s", _("Table not found"));
if (out_error)
*out_error = TRUE;
return NULL;
}
if ((dbo->obj_type != GDA_META_DB_TABLE) && (dbo->obj_type != GDA_META_DB_VIEW)) {
g_set_error (error, MGR_COLUMNS_ERROR, MGR_COLUMNS_WRONG_OBJ_TYPE,
"%s", _("Requested object is not a table or view"));
if (out_error)
*out_error = TRUE;
return NULL;
}
GdaMetaTable *dbotable;
GSList *columns;
gint index;
dbotable = GDA_META_TABLE (dbo);
for (columns = dbotable->columns, index = 0;
columns;
columns = columns->next, index ++) {
GdaMetaTableColumn *col;
col = GDA_META_TABLE_COLUMN (columns->data);
GdaTreeNode* snode = NULL;
GValue *av;
if (ehash)
snode = g_hash_table_lookup (ehash, col->column_name);
if (snode) {
/* use the same node */
g_object_ref (G_OBJECT (snode));
}
else {
/* column's name */
snode = gda_tree_manager_create_node (manager, node, NULL);
if (col->pkey)
g_value_take_string ((av = gda_value_new (G_TYPE_STRING)),
g_strdup_printf ("<b>%s</b>", col->column_name));
else
g_value_set_string ((av = gda_value_new (G_TYPE_STRING)), col->column_name);
gda_tree_node_set_node_attribute (snode, MGR_COLUMNS_COL_NAME_ATT_NAME, av, NULL);
gda_value_free (av);
}
/* column's type */
g_value_set_string ((av = gda_value_new (G_TYPE_STRING)), col->column_type);
gda_tree_node_set_node_attribute (snode, MGR_COLUMNS_COL_TYPE_ATT_NAME, av, NULL);
gda_value_free (av);
/* NOT NULL */
g_value_set_boolean ((av = gda_value_new (G_TYPE_BOOLEAN)), !col->nullok);
gda_tree_node_set_node_attribute (snode, MGR_COLUMNS_COL_NOTNULL_ATT_NAME, av, NULL);
gda_value_free (av);
/* default value */
g_value_set_string ((av = gda_value_new (G_TYPE_STRING)), col->default_value);
gda_tree_node_set_node_attribute (snode, MGR_COLUMNS_COL_DEFAULT_ATT_NAME, av, NULL);
gda_value_free (av);
/* icon */
UiIconType type = UI_ICON_COLUMN;
GdkPixbuf *pixbuf;
gboolean is_fk = column_is_fk_part (dbo, index);
if (col->pkey)
type = UI_ICON_COLUMN_PK;
else if (!col->nullok) {
if (is_fk)
type = UI_ICON_COLUMN_FK_NN;
else
type = UI_ICON_COLUMN_NN;
}
else if (is_fk)
type = UI_ICON_COLUMN_FK;
pixbuf = ui_get_pixbuf_icon (type);
av = gda_value_new (G_TYPE_OBJECT);
g_value_set_object (av, pixbuf);
gda_tree_node_set_node_attribute (snode, "icon", av, NULL);
gda_value_free (av);
/* details */
GString *details = NULL;
if (col->pkey)
details = g_string_new (_("Primary key"));
if (is_fk) {
if (details)
g_string_append (details, ", ");
else
details = g_string_new ("");
g_string_append (details, _("Foreign key"));
}
const GValue *autoinc;
autoinc = gda_meta_table_column_get_attribute (col, GDA_ATTRIBUTE_AUTO_INCREMENT);
if (autoinc) {
if (details)
g_string_append (details, ", ");
else
details = g_string_new ("");
g_string_append (details, _("Auto incremented"));
}
if (details) {
g_value_set_string ((av = gda_value_new (G_TYPE_STRING)), details->str);
gda_tree_node_set_node_attribute (snode, MGR_COLUMNS_COL_DETAILS, av, NULL);
gda_value_free (av);
g_string_free (details, TRUE);
}
nodes_list = g_slist_prepend (nodes_list, snode);
}
if (ehash)
g_hash_table_destroy (ehash);
return g_slist_reverse (nodes_list);
}
int
main (int argc, char *argv [])
{
GdaDataModel *model;
gint i, nrows;
GError *error = NULL;
gda_init ();
if (! g_file_test (DATABASE, G_FILE_TEST_EXISTS)) {
g_print ("File '%s' does not exist\n", DATABASE);
exit (1);
}
model = gda_data_model_bdb_new (DATABASE, NULL);
gda_data_model_dump (model, stdout);
nrows = gda_data_model_get_n_rows (model);
for (i = 0; i < nrows; i++) {
Key *key;
Value *value;
const GValue *c_value;
const GdaBinary *bin;
g_print ("=============== ROW %d\n", i);
c_value= gda_data_model_get_value_at (model, 0, i, &error);
if (!c_value) {
g_print ("Could not get value from data model: %s\n",
error && error->message ? error->message : "No detail");
exit (1);
}
bin = gda_value_get_binary (c_value);
key = (Key *)bin->data;
g_print ("color/type = %s/%d\n", key->color, key->type);
c_value= gda_data_model_get_value_at (model, 1, i, &error);
if (!c_value) {
g_print ("Could not get value from data model: %s\n",
error && error->message ? error->message : "No detail");
exit (1);
}
bin = gda_value_get_binary (c_value);
value = (Value *)bin->data;
g_print ("size/name = %f/%s\n", value->size, value->name);
}
i = gda_data_model_append_row (model, &error);
if (i < 0) {
g_print ("Could not append row: %s\n",
error && error->message ? error->message : "no detail");
exit (1);
}
else {
{
/* EXTRA tests */
gda_data_model_dump (model, stdout);
if (!gda_data_model_remove_row (model, i, &error)) {
g_print ("Could not remove row: %s\n",
error && error->message ? error->message : "no detail");
exit (1);
}
gda_data_model_dump (model, stdout);
gchar *str = "AAA";
GValue *value = gda_value_new_binary ((guchar*) str, 4);
if (!gda_data_model_set_value_at (model, 1, 2, value, &error)) {
g_print ("Could not set value: %s\n",
error && error->message ? error->message : "no detail");
exit (1);
}
gda_data_model_dump (model, stdout);
exit (0);
}
GValue *value;
GdaBinary bin;
Key m_key;
Value m_value;
strncpy (m_key.color, "black", COLORSIZE);
m_key.type = 100;
bin.data = (gpointer) &m_key;
bin.binary_length = sizeof (Key);
value = gda_value_new (GDA_TYPE_BINARY);
gda_value_set_binary (value, &bin);
if (!gda_data_model_set_value_at (model, 0, i, value, &error)) {
g_print ("Could not set key: %s\n",
error && error->message ? error->message : "no detail");
exit (1);
}
gda_value_free (value);
m_value.size = 100.1;
strncpy (m_value.name, "blackhole", NAMESIZE);
bin.data = (gpointer) &m_value;
bin.binary_length = sizeof (Value);
value = gda_value_new (GDA_TYPE_BINARY);
gda_value_set_binary (value, &bin);
if (!gda_data_model_set_value_at (model, 1, i, value, &error)) {
g_print ("Could not set key: %s\n",
error && error->message ? error->message : "no detail");
exit (1);
}
gda_value_free (value);
}
g_object_unref (model);
return 0;
}
GtkWidget *
relations_diagram_new_with_fav_id (TConnection *tcnc, gint fav_id, GError **error)
{
RelationsDiagram *diagram = NULL;
TFavoritesAttributes fav;
xmlDocPtr doc = NULL;
if (! t_favorites_get (t_connection_get_favorites (tcnc),
fav_id, &fav, error))
return FALSE;
doc = xmlParseDoc (BAD_CAST fav.contents);
if (!doc) {
g_set_error (error, T_ERROR, T_INTERNAL_COMMAND_ERROR,
"%s", _("Error parsing favorite's contents"));
goto out;
}
/* create diagram */
diagram = RELATIONS_DIAGRAM (relations_diagram_new (tcnc));
if (!diagram)
goto out;
gchar *str, *tmp;
tmp = g_markup_printf_escaped (_("'%s' diagram"), fav.name);
str = g_strdup_printf ("<b>%s</b>\n%s", _("Relations diagram"), tmp);
g_free (tmp);
gdaui_bar_set_text (diagram->priv->header, str);
g_free (str);
diagram->priv->fav_id = fav_id;
relations_diagram_set_fav_id (diagram, fav_id, NULL);
/* fill the diagram */
xmlNodePtr root, node;
root = xmlDocGetRootElement (doc);
if (!root)
goto out;
for (node = root->children; node; node = node->next) {
if (!strcmp ((gchar*) node->name, "table")) {
xmlChar *schema;
xmlChar *name;
schema = xmlGetProp (node, BAD_CAST "schema");
name = xmlGetProp (node, BAD_CAST "name");
if (schema && name) {
BrowserCanvasTable *table;
GValue *v1, *v2;
g_value_set_string ((v1 = gda_value_new (G_TYPE_STRING)), (gchar*) schema);
g_value_set_string ((v2 = gda_value_new (G_TYPE_STRING)), (gchar*) name);
xmlFree (schema);
xmlFree (name);
table = browser_canvas_db_relations_add_table (BROWSER_CANVAS_DB_RELATIONS (diagram->priv->canvas),
NULL, v1, v2);
gda_value_free (v1);
gda_value_free (v2);
if (table) {
xmlChar *x, *y;
x = xmlGetProp (node, BAD_CAST "x");
y = xmlGetProp (node, BAD_CAST "y");
browser_canvas_translate_item (BROWSER_CANVAS (diagram->priv->canvas),
(BrowserCanvasItem*) table,
x ? g_ascii_strtod ((gchar*) x, NULL) : 0.,
y ? g_ascii_strtod ((gchar*) y, NULL) : 0.);
if (x)
xmlFree (x);
if (y)
xmlFree (y);
}
}
else {
if (schema)
xmlFree (schema);
if (name)
xmlFree (name);
g_set_error (error, T_ERROR, T_STORED_DATA_ERROR,
"%s", _("Missing table attribute in favorite's contents"));
gtk_widget_destroy ((GtkWidget*) diagram);
diagram = NULL;
goto out;
}
}
}
out:
t_favorites_reset_attributes (&fav);
if (doc)
xmlFreeDoc (doc);
return (GtkWidget*) diagram;
}
int
main (int argc, char *argv[])
{
gda_init ();
GdaConnection *cnc;
GError *error = NULL;
GdaStatement *stmt;
GdaDataModel *model;
gchar *str;
GValue *name;
/* open connection */
cnc = open_connection ();
/* begin transaction */
if (! gda_connection_begin_transaction (cnc, NULL, GDA_TRANSACTION_ISOLATION_UNKNOWN,
&error)) {
g_print ("Could not begin transaction: %s\n",
error && error->message ? error->message : "No detail");
exit (1);
}
/* execute SELECT */
stmt = gda_sql_parser_parse_string (parser, "SELECT id, name FROM customers ORDER BY id", NULL, NULL);
g_assert (stmt);
model = gda_connection_statement_execute_select (cnc, stmt, NULL, &error);
g_object_unref (stmt);
if (!model) {
g_print ("Could not execute SELECT statement: %s\n",
error && error->message ? error->message : "No detail");
exit (1);
}
g_print ("** Data model is:\n");
gda_data_model_dump (model, stdout);
/*
* make sure the mete data is up to date
*/
g_print ("Computing meta data, this may take a while; in real applications, this should be cached to avoid waiting\n");
if (! gda_connection_update_meta_store (cnc, NULL, &error)) {
g_print ("Could not fetch meta data: %s\n",
error && error->message ? error->message : "No detail");
exit (1);
}
/*
* Make the data model compute the modification statements which
* will actually be executed when the data model is modified
*/
if (! gda_data_select_compute_modification_statements (GDA_DATA_SELECT (model), &error)) {
g_print ("Could not compute modification statements: %s\n",
error && error->message ? error->message : "No detail");
exit (1);
}
g_object_get (G_OBJECT (model), "update-stmt", &stmt, NULL);
str = gda_statement_to_sql (stmt, NULL, NULL);
g_print ("Computed UPDATE: %s\n", str);
g_free (str);
g_object_unref (stmt);
g_object_get (G_OBJECT (model), "delete-stmt", &stmt, NULL);
str = gda_statement_to_sql (stmt, NULL, NULL);
g_print ("Computed DELETE: %s\n", str);
g_free (str);
g_object_unref (stmt);
g_object_get (G_OBJECT (model), "insert-stmt", &stmt, NULL);
str = gda_statement_to_sql (stmt, NULL, NULL);
g_print ("Computed INSERT: %s\n", str);
g_free (str);
g_object_unref (stmt);
/*
* remove row 0 (1st row)
*/
g_print ("\n\n** Removing row 0\n");
if (! gda_data_model_remove_row (model, 0, &error)) {
g_print ("Could not remove row 0: %s\n",
error && error->message ? error->message : "No detail");
exit (1);
}
g_print ("** Data model is now:\n");
gda_data_model_dump (model, stdout);
g_print ("** Table's contents is now:\n");
display_customers (cnc);
/*
* add a row: the row's values is a list of GValue pointers
* (or NULL pointers where the default value should be inserted
*/
GList *list;
g_print ("\n\n** Adding a row\n");
list = g_list_append (NULL, NULL);
g_value_set_string ((name = gda_value_new (G_TYPE_STRING)), "Hiro");
list = g_list_append (list, name);
if (gda_data_model_append_values (model, list, &error) == -1) {
g_print ("Could not add a row: %s\n",
error && error->message ? error->message : "No detail");
exit (1);
}
gda_value_free (name);
g_list_free (list);
g_print ("** Data model is now:\n");
gda_data_model_dump (model, stdout);
g_print ("** Table's contents is now:\n");
display_customers (cnc);
/*
* alter row 2
*/
g_print ("\n\n** Modifying row 2\n");
g_value_set_string ((name = gda_value_new (G_TYPE_STRING)), "Tom");
if (! gda_data_model_set_value_at (model, 1, 2, name, &error)) {
g_print ("Could not modify row 2: %s\n",
error && error->message ? error->message : "No detail");
exit (1);
}
gda_value_free (name);
g_print ("** Data model is now:\n");
gda_data_model_dump (model, stdout);
g_print ("** Table's contents is now:\n");
display_customers (cnc);
/* rollback transaction */
gda_connection_rollback_transaction (cnc, NULL, NULL);
gda_connection_close (cnc);
return 0;
}
static GdaValueAttribute
gdaui_entry_wrapper_get_attributes (GdauiDataEntry *iface)
{
GdaValueAttribute retval = 0;
GdauiEntryWrapper *wrapper;
GValue *value = NULL;
g_return_val_if_fail (GDAUI_IS_ENTRY_WRAPPER (iface), 0);
wrapper = (GdauiEntryWrapper*) iface;
check_correct_init (wrapper);
gboolean specific_impl = TRUE;
if (!wrapper->priv->real_class->value_is_equal_to ||
!wrapper->priv->real_class->value_is_null) {
value = gdaui_entry_wrapper_get_value (iface); /* @value may NOT be @NULL ! */
g_assert (value);
specific_impl = FALSE;
}
/* can be NULL? */
if (wrapper->priv->null_possible)
retval |= GDA_VALUE_ATTR_CAN_BE_NULL;
/* can be default? */
if (wrapper->priv->default_possible)
retval |= GDA_VALUE_ATTR_CAN_BE_DEFAULT;
/* NULL? */
gboolean value_is_null = FALSE;
if (specific_impl) {
if ((wrapper->priv->real_class->value_is_null) (wrapper))
value_is_null = TRUE;
}
else {
if (G_VALUE_TYPE (value) == GDA_TYPE_NULL) {
if (wrapper->priv->default_forced) {
if (wrapper->priv->null_forced)
value_is_null = TRUE;
}
else
value_is_null = TRUE;
}
}
if (value_is_null)
retval |= GDA_VALUE_ATTR_IS_NULL;
/* is default */
if (wrapper->priv->default_forced)
retval |= GDA_VALUE_ATTR_IS_DEFAULT;
else {
/* is unchanged */
if (wrapper->priv->value_ref) {
if (specific_impl) {
if ((wrapper->priv->real_class->value_is_equal_to) (wrapper, wrapper->priv->value_ref))
retval |= GDA_VALUE_ATTR_IS_UNCHANGED;
}
else if (G_VALUE_TYPE (value) == G_VALUE_TYPE (wrapper->priv->value_ref)) {
if (! gda_value_differ (value, wrapper->priv->value_ref))
retval |= GDA_VALUE_ATTR_IS_UNCHANGED;
}
}
}
/* data valid? */
if (wrapper->priv->invalid ||
(value_is_null && !wrapper->priv->null_possible))
retval |= GDA_VALUE_ATTR_DATA_NON_VALID;
/* has original value? */
if (wrapper->priv->value_ref)
retval |= GDA_VALUE_ATTR_HAS_VALUE_ORIG;
gda_value_free (value);
/* editable ? */
if (!wrapper->priv->editable)
retval |= GDA_VALUE_ATTR_READ_ONLY;
#ifdef DEBUG
g_print ("%s (%p): %s%s%s%s%s%s%s%s\n", __FUNCTION__, iface,
(retval & GDA_VALUE_ATTR_IS_NULL) ? "IS_NULL " : " ",
(retval & GDA_VALUE_ATTR_CAN_BE_NULL) ? "CAN_BE_NULL " : " ",
(retval & GDA_VALUE_ATTR_IS_DEFAULT) ? "IS_DEFAULT " : " ",
(retval & GDA_VALUE_ATTR_CAN_BE_DEFAULT) ? "CAN_BE_DEFAULT " : " ",
(retval & GDA_VALUE_ATTR_IS_UNCHANGED) ? "IS_UNCHANGED " : " ",
(retval & GDA_VALUE_ATTR_DATA_NON_VALID) ? "NON_VALID " : " ",
(retval & GDA_VALUE_ATTR_READ_ONLY) ? "READ_ONLY " : " ",
(retval & GDA_VALUE_ATTR_HAS_VALUE_ORIG) ? "HAS_VALUE_ORIG " : " ");
#endif
return retval;
}
GtkWidget *
do_data_model_dir (GtkWidget *do_widget)
{
if (!window) {
GtkWidget *vbox;
GtkWidget *label;
GdaDataModel *model;
GtkWidget *form, *grid, *nb;
GdaSet *data_set;
GdaHolder *param;
gchar *path;
GValue *value;
window = gtk_dialog_new_with_buttons ("GdaDataModelDir data model",
GTK_WINDOW (do_widget),
0,
GTK_STOCK_CLOSE,
GTK_RESPONSE_NONE,
NULL);
g_signal_connect (window, "response",
G_CALLBACK (gtk_widget_destroy), NULL);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (window))),
vbox, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
label = gtk_label_new ("The following GdauiForm widget displays data from a GdaDataModelDir "
"data model which lists the files contained in the selected directory.\n\n"
"Each file contents is then displayed using the 'picture' plugin \n"
"(right click to open a menu, or double click to load an image).");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
/* GdaDataModelDir object */
path = get_data_path ();
model = gda_data_model_dir_new (path);
g_free (path);
/* Create the demo widget */
nb = gtk_notebook_new ();
gtk_box_pack_start (GTK_BOX (vbox), nb, TRUE, TRUE, 0);
form = gdaui_form_new (model);
gtk_notebook_append_page (GTK_NOTEBOOK (nb), form, gtk_label_new ("Form"));
grid = gdaui_grid_new (model);
gtk_notebook_append_page (GTK_NOTEBOOK (nb), grid, gtk_label_new ("Grid"));
g_object_unref (model);
/* specify that we want to use the 'picture' plugin */
data_set = GDA_SET (gdaui_data_selector_get_data_set (GDAUI_DATA_SELECTOR (grid)));
param = gda_set_get_holder (data_set, "data");
value = gda_value_new_from_string ("picture", G_TYPE_STRING);
gda_holder_set_attribute_static (param, GDAUI_ATTRIBUTE_PLUGIN, value);
gdaui_data_proxy_column_show_actions (GDAUI_DATA_PROXY (grid), -1, TRUE);
gda_value_free (value);
}
gboolean visible;
g_object_get (G_OBJECT (window), "visible", &visible, NULL);
if (!visible)
gtk_widget_show_all (window);
else {
gtk_widget_destroy (window);
window = NULL;
}
return window;
}
/*
* Load data from file @file into table @table
*/
gboolean
test_cnc_load_data_from_file (GdaConnection *cnc, const gchar *table, const gchar *full_file, GError **error)
{
GdaStatement *stmt = NULL;
GdaSet *params = NULL;
GdaDataModel *import;
gint nrows, ncols, i;
GdaMetaStruct *mstruct = NULL;
GSList *list;
gboolean retval = TRUE;
/* loading XML file */
import = gda_data_model_import_new_file (full_file, TRUE, NULL);
if (gda_data_model_import_get_errors (GDA_DATA_MODEL_IMPORT (import))) {
g_set_error (error, TEST_ERROR, TEST_ERROR_GENERIC, "Error loading '%s' file", full_file);
return FALSE;
}
/* retrieving meta data info */
GdaMetaDbObject *table_dbo;
GValue *name_value;
g_value_set_string ((name_value = gda_value_new (G_TYPE_STRING)), table);
mstruct = gda_meta_struct_new (gda_connection_get_meta_store (cnc), GDA_META_STRUCT_FEATURE_NONE);
table_dbo = gda_meta_struct_complement (mstruct, GDA_META_DB_TABLE,
NULL, NULL, name_value, error);
gda_value_free (name_value);
if (! table_dbo) {
retval = FALSE;
goto out;
}
/* creating INSERT statement */
GdaSqlStatement *st;
GdaSqlStatementInsert *ist;
GSList *insert_values_list = NULL;
ist = g_new0 (GdaSqlStatementInsert, 1);
GDA_SQL_ANY_PART (ist)->type = GDA_SQL_ANY_STMT_INSERT;
ist->table = gda_sql_table_new (GDA_SQL_ANY_PART (ist));
ist->table->table_name = g_strdup (table);
GdaMetaTable *mtable = GDA_META_TABLE (table_dbo);
for (list = mtable->columns; list; list = list->next) {
GdaMetaTableColumn *tcol = GDA_META_TABLE_COLUMN (list->data);
GdaSqlField *field;
/* field */
field = gda_sql_field_new (GDA_SQL_ANY_PART (ist));
field->field_name = g_strdup (tcol->column_name);
ist->fields_list = g_slist_append (ist->fields_list, field);
/* value */
GdaSqlParamSpec *pspec = g_new0 (GdaSqlParamSpec, 1);
GdaSqlExpr *expr;
pspec->name = g_strdup (tcol->column_name);
pspec->g_type = tcol->gtype;
pspec->nullok = tcol->nullok;
expr = gda_sql_expr_new (GDA_SQL_ANY_PART (ist));
expr->param_spec = pspec;
insert_values_list = g_slist_append (insert_values_list, expr);
}
ist->values_list = g_slist_append (NULL, insert_values_list);
st = gda_sql_statement_new (GDA_SQL_STATEMENT_INSERT);
st->contents = ist;
stmt = g_object_new (GDA_TYPE_STATEMENT, "structure", st, NULL);
gda_sql_statement_free (st);
g_object_unref (mstruct);
if (! gda_statement_get_parameters (stmt, ¶ms, error)) {
retval = FALSE;
goto out;
}
/* executing inserts */
nrows = gda_data_model_get_n_rows (import);
ncols = gda_data_model_get_n_columns (import);
if (!gda_connection_begin_transaction (cnc, NULL, GDA_TRANSACTION_ISOLATION_UNKNOWN, error)) {
retval = FALSE;
goto out;
}
for (i = 0; i < nrows; i++) {
gint j;
GSList *list;
for (list = params->holders, j = 0; list && (j < ncols); list = list->next, j++) {
const GValue *cvalue = gda_data_model_get_value_at (import, j, i, error);
if (!cvalue) {
gda_connection_rollback_transaction (cnc, NULL, NULL);
retval = FALSE;
goto out;
}
if (! gda_holder_set_value (GDA_HOLDER (list->data), cvalue, error)) {
gda_connection_rollback_transaction (cnc, NULL, NULL);
retval = FALSE;
goto out;
}
}
if (list || (j < ncols)) {
g_set_error (error, TEST_ERROR, TEST_ERROR_GENERIC, "%s",
"Incoherent number of columns in table and imported data");
gda_connection_rollback_transaction (cnc, NULL, NULL);
retval = FALSE;
goto out;
}
if (gda_connection_statement_execute_non_select (cnc, stmt, params, NULL, error) == -1) {
gda_connection_rollback_transaction (cnc, NULL, NULL);
retval = FALSE;
goto out;
}
}
if (! gda_connection_commit_transaction (cnc, NULL, error))
retval = FALSE;
out:
if (import)
g_object_unref (import);
if (stmt)
g_object_unref (stmt);
if (params)
g_object_unref (params);
return retval;
}
