static gboolean
update_blob (GdaConnection *cnc, gint id, const gchar *data, glong binary_length, GError **error)
{
GdaStatement *stmt;
GdaSet *plist;
GdaHolder *param;
GValue *value;
gchar *str;
gboolean retval;
const gchar* SQL_UPDATE = "UPDATE blobs set name = ##/*name:'name' type:gchararray*/, data = ##/*name:'theblob' type:'GdaBlob'*/ WHERE id= ##/*name:'id' type:gint*/";
show_header ("Update a blob");
stmt = gda_sql_parser_parse_string (parser, SQL_UPDATE, NULL, error);
if (!stmt)
return FALSE;
if (!gda_statement_get_parameters (stmt, &plist, NULL))
return FALSE;
/* blob id */
param = gda_set_get_holder (plist, "id");
str = g_strdup_printf ("%d", id);
if (! gda_holder_set_value_str (param, NULL, str, error))
return FALSE;
g_free (str);
/* blob name */
param = gda_set_get_holder (plist, "name");
str = g_strdup_printf ("BLOB_%d", id);
if (! gda_holder_set_value_str (param, NULL, str, error))
return FALSE;
g_free (str);
/* blob data */
param = gda_set_get_holder (plist, "theblob");
value = gda_value_new_blob ((guchar*) data, binary_length);
if (! gda_holder_set_value (param, value, error))
return FALSE;
gda_value_free (value);
gda_connection_clear_events_list (cnc);
retval = exec_statement (cnc, stmt, plist, error);
g_object_unref (stmt);
g_object_unref (plist);
return retval;
}
/*
* _gdaui_provider_auth_editor_set_auths
* @auth: a #GdauiProviderAuthEditor widget
* @auth_string:
*
* Sets the connection string to be displayed in the widget
*/
void
_gdaui_provider_auth_editor_set_auth (GdauiProviderAuthEditor *auth, const gchar *auth_string)
{
g_return_if_fail (GDAUI_IS_PROVIDER_AUTH_EDITOR (auth));
g_return_if_fail (auth->priv);
if (!auth->priv->pinfo)
return;
if (!auth->priv->auth_needed) {
if (auth_string && *auth_string)
g_warning (_("Can't set authentification string: no authentication is needed"));
return;
}
gdaui_basic_form_reset (GDAUI_BASIC_FORM (auth->priv->auth_widget));
if (auth_string) {
/* split array in a list of named parameters, and for each parameter value, set the correcponding
parameter in @dset */
GdaSet *dset;
GSList *params_set = NULL;
g_assert (auth->priv->auth_widget);
dset = gdaui_basic_form_get_data_set (GDAUI_BASIC_FORM (auth->priv->auth_widget));
gchar **array = NULL;
array = g_strsplit (auth_string, ";", 0);
if (array) {
gint index = 0;
gchar *tok;
gchar *value;
gchar *name;
for (index = 0; array[index]; index++) {
name = strtok_r (array [index], "=", &tok);
if (name)
value = strtok_r (NULL, "=", &tok);
else
value = NULL;
if (name && value) {
GdaHolder *param;
gda_rfc1738_decode (name);
gda_rfc1738_decode (value);
param = gda_set_get_holder (dset, name);
if (param)
if (gda_holder_set_value_str (param, NULL, value, NULL))
params_set = g_slist_prepend (params_set, param);
}
}
g_strfreev (array);
}
}
g_signal_emit_by_name (auth, "changed");
}
/*
* ... is a list of (const gchar *name, const gchar *value) couples, terminated by %NULL
*/
static guint
request_execution_with_params (GdaConnection *cnc, const gchar *sql, ...)
{
GdaStatement *stmt;
guint id;
GError *error = NULL;
GdaSet *params;
const gchar *pname;
g_print ("=========== Async. exececution request:\n%s\n", sql);
stmt = create_statement (sql);
if (! gda_statement_get_parameters (stmt, ¶ms, &error)) {
g_print ("Can't get statement's parameters: %s\n", error && error->message ? error->message : "No detail");
exit (1);
}
if (params) {
va_list ap;
va_start (ap, sql);
for (pname = va_arg (ap, const gchar *); pname; pname = va_arg (ap, const gchar *)) {
const gchar *value;
GdaHolder *holder;
holder = gda_set_get_holder (params, pname);
value = va_arg (ap, const gchar *);
if (holder)
g_assert (gda_holder_set_value_str (holder, NULL, value, NULL));
g_print ("\t%s => %s\n", pname, value);
va_end (ap);
}
}
id = gda_connection_async_statement_execute (cnc, stmt, params, GDA_STATEMENT_MODEL_RANDOM_ACCESS, NULL, FALSE,
&error);
if (params)
g_object_unref (params);
g_object_unref (stmt);
if (id == 0) {
g_print ("Can't execute ASYNC: %s\n", error && error->message ? error->message : "No detail");
exit (1);
}
g_print ("Assigned task id: %u\n", id);
return id;
}
/*
* run_context_find_param
*
* Find a parameter in the context
*/
static GdaHolder *
run_context_find_param (GdaReportEngine *engine, RunContext *context, const xmlChar *name)
{
GdaHolder *retval = NULL;
RunContext *ctx;
gchar **array;
/*g_print ("%s (context=%p, name=%s) ", __FUNCTION__, context, name);*/
array = g_strsplit ((gchar *) name, "|", 0);
if (g_strv_length (array) == 2) {
gchar *model_name = array [0];
gchar *col_name = array [1];
/* search through the contexts for a [data model]/[column name] parameter */
for (ctx = context; ctx; ctx = ctx->parent) {
if (!ctx->model || !ctx->iter)
continue;
const gchar *obj_name;
obj_name = g_object_get_data (G_OBJECT (ctx->model), "name");
if (obj_name && !strcmp (obj_name, model_name)) {
if (*col_name == '@')
retval = gda_set_get_holder (GDA_SET (ctx->iter), col_name + 1);
else if (*col_name == '#') {
gint nth = atoi (col_name + 1);
retval = g_slist_nth_data (GDA_SET (ctx->iter)->holders, nth);
}
else
retval = g_object_get_data (G_OBJECT (ctx->model), (gchar*) name);
break;
}
}
}
g_strfreev (array);
/* try among the engine's declared parameters */
if (!retval)
retval = (GdaHolder *) gda_report_engine_find_declared_object (engine, GDA_TYPE_HOLDER,
(gchar *) name);
/*g_print ("=> %p\n", retval);*/
return retval;
}
static void
gda_tree_mgr_select_set_property (GObject *object,
guint param_id,
const GValue *value,
GParamSpec *pspec)
{
GdaTreeMgrSelect *mgr;
mgr = GDA_TREE_MGR_SELECT (object);
if (mgr->priv) {
switch (param_id) {
case PROP_CNC:
mgr->priv->cnc = (GdaConnection*) g_value_get_object (value);
if (mgr->priv->cnc)
g_object_ref (mgr->priv->cnc);
break;
case PROP_STMT:
mgr->priv->stmt = (GdaStatement*) g_value_get_object (value);
if (mgr->priv->stmt) {
GError *lerror = NULL;
g_object_ref (mgr->priv->stmt);
if (!gda_statement_get_parameters (mgr->priv->stmt, &(mgr->priv->priv_params), &lerror)) {
g_warning (_("Could not get SELECT statement's parameters: %s"),
lerror && lerror->message ? lerror->message : _("No detail"));
if (lerror)
g_error_free (lerror);
}
if (mgr->priv->priv_params && mgr->priv->priv_params->holders)
mgr->priv->non_bound_params = g_slist_copy (mgr->priv->priv_params->holders);
}
break;
case PROP_PARAMS:
mgr->priv->params = (GdaSet*) g_value_get_object (value);
if (mgr->priv->params)
g_object_ref (mgr->priv->params);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
break;
}
}
if (mgr->priv->priv_params && mgr->priv->params) {
/* bind holders in mgr->priv->priv_params to the ones in mgr->priv->params
* if they exist */
GSList *params;
GSList *non_bound_params = NULL;
g_slist_free (mgr->priv->non_bound_params);
for (params = mgr->priv->priv_params->holders; params; params = params->next) {
GdaHolder *frh = GDA_HOLDER (params->data);
GdaHolder *toh = gda_set_get_holder (mgr->priv->params, gda_holder_get_id (frh));
if (toh) {
GError *lerror = NULL;
if (!gda_holder_set_bind (frh, toh, &lerror)) {
g_warning (_("Could not bind SELECT statement's parameter '%s' "
"to provided parameters: %s"),
gda_holder_get_id (frh),
lerror && lerror->message ? lerror->message : _("No detail"));
if (lerror)
g_error_free (lerror);
non_bound_params = g_slist_prepend (non_bound_params, frh);
}
}
else
non_bound_params = g_slist_prepend (non_bound_params, frh);
}
mgr->priv->non_bound_params = non_bound_params;
}
}
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;
}
static GSList *
gda_tree_mgr_columns_update_children (GdaTreeManager *manager, GdaTreeNode *node, G_GNUC_UNUSED const GSList *children_nodes,
gboolean *out_error, GError **error)
{
GdaTreeMgrColumns *mgr = GDA_TREE_MGR_COLUMNS (manager);
GdaMetaStore *store;
GdaDataModel *model;
GSList *list = NULL;
GdaConnection *scnc;
GdaTreeMgrColumnsPrivate *priv = gda_tree_mgr_columns_get_instance_private (mgr);
if (!priv->cnc && !priv->mstore) {
g_set_error (error, GDA_TREE_MANAGER_ERROR, GDA_TREE_MANAGER_UNKNOWN_ERROR,
"%s", _("No connection and no GdaMetaStore specified"));
if (out_error)
*out_error = TRUE;
return NULL;
}
else if (priv->mstore)
store = priv->mstore;
else
store = gda_connection_get_meta_store (priv->cnc);
scnc = gda_meta_store_get_internal_connection (store);
/* create statements if necessary */
if (!priv->stmt) {
GdaSqlParser *parser;
GdaStatement *stmt;
parser = gda_connection_create_parser (scnc);
if (! parser)
parser = gda_sql_parser_new ();
stmt = gda_sql_parser_parse_string (parser,
"SELECT column_name FROM _columns WHERE "
"table_schema= ##schema::string AND "
"table_name= ##table_name::string "
"ORDER BY ordinal_position", NULL, error);
g_object_unref (parser);
if (!stmt) {
if (out_error)
*out_error = TRUE;
return NULL;
}
if (!gda_statement_get_parameters (stmt, &(priv->params), error)) {
if (out_error)
*out_error = TRUE;
g_object_unref (stmt);
return NULL;
}
priv->stmt = stmt;
}
gboolean schema_specified = FALSE;
gboolean table_specified = FALSE;
if (priv->schema) {
schema_specified = TRUE;
g_assert (gda_set_set_holder_value (priv->params, NULL, "schema",
priv->schema));
}
if (priv->table_name) {
table_specified = TRUE;
g_assert (gda_set_set_holder_value (priv->params, NULL, "table_name",
priv->table_name));
}
if (!schema_specified && node) {
/* looking for a schema in @node's attributes */
const GValue *cvalue;
cvalue = gda_tree_node_fetch_attribute (node, "schema");
if (cvalue) {
GdaHolder *h = gda_set_get_holder (priv->params, "schema");
if (!gda_holder_set_value (h, cvalue, error)) {
if (out_error)
*out_error = TRUE;
return NULL;
}
schema_specified = TRUE;
}
}
if (!table_specified && node) {
/* looking for a table in @node's attributes */
const GValue *cvalue;
cvalue = gda_tree_node_fetch_attribute (node, "table_name");
if (cvalue) {
GdaHolder *h = gda_set_get_holder (priv->params, "table_name");
if (!gda_holder_set_value (h, cvalue, error)) {
if (out_error)
*out_error = TRUE;
return NULL;
}
table_specified = TRUE;
}
}
if (!schema_specified) {
g_set_error (error, GDA_TREE_MANAGER_ERROR, GDA_TREE_MANAGER_UNKNOWN_ERROR,
"%s", _("No schema specified"));
if (out_error)
*out_error = TRUE;
return NULL;
}
if (!table_specified) {
g_set_error (error, GDA_TREE_MANAGER_ERROR, GDA_TREE_MANAGER_UNKNOWN_ERROR,
"%s", _("No table specified"));
if (out_error)
*out_error = TRUE;
return NULL;
}
model = gda_connection_statement_execute_select (scnc, priv->stmt, priv->params, error);
if (!model) {
if (out_error)
*out_error = TRUE;
return NULL;
}
GdaDataModelIter *iter;
iter = gda_data_model_create_iter (model);
for (; iter && gda_data_model_iter_move_next (iter);) {
GdaTreeNode* snode;
const GValue *cvalue;
cvalue = gda_data_model_iter_get_value_at (iter, 0);
if (!cvalue) {
if (list) {
g_slist_free_full (list, (GDestroyNotify) g_object_unref);
}
if (out_error)
*out_error = TRUE;
g_set_error (error, GDA_TREE_MANAGER_ERROR, GDA_TREE_MANAGER_UNKNOWN_ERROR,
"%s", _("Unable to get column name"));
return NULL;
}
snode = gda_tree_manager_create_node (manager, node, g_value_get_string (cvalue));
gda_tree_node_set_node_attribute (snode, "column_name", cvalue, NULL);
list = g_slist_prepend (list, snode);
}
if (iter)
g_object_unref (iter);
g_object_unref (model);
return list;
}
static void
selection_changed_cb (GtkTreeSelection *select, BrowserConnectionsList *clist)
{
GtkTreeModel *model;
GtkTreeIter iter;
BrowserConnection *bcnc = NULL;
const GdaDsnInfo *cncinfo = NULL;
if (gtk_tree_selection_get_selected (select, &model, &iter)) {
gtk_tree_model_get (model, &iter, COLUMN_BCNC, &bcnc, -1);
cncinfo = browser_connection_get_information (bcnc);
g_object_unref (bcnc);
gtk_widget_set_sensitive (_clist->priv->close_cnc_button, TRUE);
}
else
gtk_widget_set_sensitive (_clist->priv->close_cnc_button, FALSE);
if (clist->priv->cnc_params_editor) {
gtk_widget_destroy (clist->priv->cnc_params_editor);
clist->priv->cnc_params_editor = NULL;
}
if (cncinfo && cncinfo->provider) {
/* create GdaSet for parameters to display */
GdaSet *dset;
GdaHolder *holder;
dset = gda_set_new_inline (1, "PROVIDER_NAME", G_TYPE_STRING, cncinfo->provider);
holder = GDA_HOLDER (dset->holders->data);
g_object_set (G_OBJECT (holder), "name", _("Database provider"), NULL);
GdaProviderInfo *pinfo;
pinfo = gda_config_get_provider_info (cncinfo->provider);
if (pinfo && pinfo->dsn_params)
gda_set_merge_with_set (dset, pinfo->dsn_params);
holder = gda_holder_new_inline (G_TYPE_STRING, "GDA_BROWSER_DICT_FILE", _("In memory"));
g_object_set (G_OBJECT (holder),
"name", _("Dictionary file"),
"description", _("File used to store any information associated\n"
"to this connection (favorites, descriptions, ...)"), NULL);
gda_set_add_holder (dset, holder);
g_object_unref (holder);
if (bcnc) {
const gchar *dict_file_name;
dict_file_name = browser_connection_get_dictionary_file (bcnc);
if (dict_file_name)
gda_set_set_holder_value (dset, NULL, "GDA_BROWSER_DICT_FILE",
dict_file_name);
}
/* create form */
GtkWidget *wid;
wid = gdaui_basic_form_new (dset);
g_object_set ((GObject*) wid, "show-actions", FALSE, NULL);
gdaui_basic_form_entry_set_editable (GDAUI_BASIC_FORM (wid), NULL, FALSE);
gtk_grid_attach (clist->priv->layout_grid, wid, 1, 2, 1, 1);
gtk_widget_show (wid);
clist->priv->cnc_params_editor = wid;
/* fill GdaSet's parameters with values */
if (cncinfo->cnc_string) {
gchar **array = NULL;
array = g_strsplit (cncinfo->cnc_string, ";", 0);
if (array) {
gint index = 0;
gchar *tok;
gchar *value;
gchar *name;
for (index = 0; array[index]; index++) {
name = strtok_r (array [index], "=", &tok);
if (name)
value = strtok_r (NULL, "=", &tok);
else
value = NULL;
if (name && value) {
GdaHolder *param;
gda_rfc1738_decode (name);
gda_rfc1738_decode (value);
param = gda_set_get_holder (dset, name);
if (param)
g_assert (gda_holder_set_value_str (param, NULL, value, NULL));
}
}
g_strfreev (array);
}
}
g_object_unref (dset);
}
}
static void
update_form_contents (GdauiProviderSpecEditor *spec)
{
/*g_print ("DSN: %s\n", spec->priv->cnc_string);*/
switch (spec->priv->type) {
case PROVIDER_FORM: {
/* update data set in form */
GdaSet *dset;
GSList *params_set = NULL;
GSList *list;
g_assert (spec->priv->form);
dset = gdaui_basic_form_get_data_set (GDAUI_BASIC_FORM (spec->priv->form));
/* split array in a list of named parameters, and for each parameter value, set the correcponding
parameter in @dset */
if (spec->priv->cnc_string) {
gchar **array = NULL;
array = g_strsplit (spec->priv->cnc_string, ";", 0);
if (array) {
gint index = 0;
gchar *tok;
gchar *value;
gchar *name;
for (index = 0; array[index]; index++) {
name = strtok_r (array [index], "=", &tok);
if (name)
value = strtok_r (NULL, "=", &tok);
else
value = NULL;
if (name && value) {
GdaHolder *param;
gda_rfc1738_decode (name);
gda_rfc1738_decode (value);
param = gda_set_get_holder (dset, name);
if (param)
if (gda_holder_set_value_str (param, NULL, value, NULL))
params_set = g_slist_prepend (params_set, param);
}
}
g_strfreev (array);
}
}
list = dset->holders;
while (0 && list) {
if (!params_set || !g_slist_find (params_set, list->data)) {
/* empty parameter */
gda_holder_set_value (GDA_HOLDER (list->data), NULL, NULL);
}
list = g_slist_next (list);
}
g_slist_free (params_set);
break;
}
default:
/* no change here */
break;
}
}
GtkWidget *
do_basic_form (GtkWidget *do_widget)
{
if (!window) {
GtkWidget *vbox;
GtkWidget *label;
GtkWidget *form;
window = gtk_dialog_new_with_buttons ("GdauiBasicForm",
GTK_WINDOW (do_widget),
0,
"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 ("This example shows 2 GdauiBasicForm widgets operating on the\n"
"same GdaSet. When a value is modified in one form, then it is\n"
"automatically updated in the other form.\n\n"
"Also the top form uses the default layout, while the bottom one\n"
"uses a custom (2 columns) layout.\n"
"The 'an int' entry is hidden in the top form.");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
/* Create the demo widget */
GdaSet *set;
gchar *filename;
set = gda_set_new_inline (3,
"a string", G_TYPE_STRING, "A string Value",
"an int", G_TYPE_INT, 12,
"a picture", GDA_TYPE_BINARY, NULL);
form = gdaui_basic_form_new (set);
gtk_box_pack_start (GTK_BOX (vbox), form, TRUE, TRUE, 0);
gdaui_basic_form_entry_set_visible (GDAUI_BASIC_FORM (form), gda_set_get_holder (set, "an int"), FALSE);
label = gtk_label_new ("2nd form is below:");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
form = gdaui_basic_form_new (set);
gtk_box_pack_start (GTK_BOX (vbox), form, TRUE, TRUE, 0);
filename = demo_find_file ("custom_layout.xml", NULL);
gdaui_basic_form_set_layout_from_file (GDAUI_BASIC_FORM (form), filename, "simple");
g_free (filename);
g_object_unref (set);
}
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;
}
GtkWidget *
do_form_data_layout (GtkWidget *do_widget)
{
if (!window) {
GdaStatement *stmt;
GtkWidget *vbox;
GtkWidget *label;
GdaDataModel *model;
GtkWidget *form;
GdauiRawForm *raw_form;
window = gtk_dialog_new_with_buttons ("Form with custom data layout",
GTK_WINDOW (do_widget),
0,
"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 information about customers,\n"
"using a paned container where the right part is used to display\n"
"a picture of the customer.\n");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
/* Create the demo widget: select all the customers and computes the total
* amount of orders they have spent */
stmt = gda_sql_parser_parse_string (demo_parser,
"select c.id, c.name, c.country, c.city, c.photo, c.comments, sum (od.quantity * (1 - od.discount/100) * p.price) as total_orders from customers c left join orders o on (c.id=o.customer) left join order_contents od on (od.order_id=o.id) left join products p on (p.ref = od.product_ref) group by c.id order by total_orders desc",
NULL, NULL);
model = gda_connection_statement_execute_select (demo_cnc, stmt, NULL, NULL);
g_object_unref (stmt);
form = gdaui_form_new (model);
g_object_unref (model);
/* hide the ID data entry */
g_object_get (G_OBJECT (form), "raw-form", &raw_form, NULL);
gdaui_basic_form_entry_set_visible (GDAUI_BASIC_FORM (raw_form),
gda_set_get_holder (gdaui_basic_form_get_data_set (GDAUI_BASIC_FORM (raw_form)),
"id"), FALSE);
/* request custom layout:
<gdaui_form name="customers" container="hpaned">
<gdaui_section title="Summary">
<gdaui_column>
<gdaui_entry name="id"/>
<gdaui_entry name="name" label="Customer name"/>
<gdaui_entry name="comments" label="Comments" plugin="text"/>
<gdaui_entry name="total_orders" label="Total ordered" plugin="number:NB_DECIMALS=2;CURRENCY=€"/>
</gdaui_column>
</gdaui_section>
<gdaui_section title="Photo">
<gdaui_column>
<gdaui_entry name="photo" plugin="picture"/>
</gdaui_column>
</gdaui_section>
</gdaui_form>
*/
gchar *filename;
filename = demo_find_file ("custom_layout.xml", NULL);
gdaui_basic_form_set_layout_from_file (GDAUI_BASIC_FORM (raw_form), filename, "customers");
g_free (filename);
/* we don't need the raw_form's reference anymore */
g_object_unref (G_OBJECT (raw_form));
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;
}
static void
form_grid_populate_popup_cb (GtkWidget *wid, GtkMenu *menu, UiFormGrid *formgrid)
{
/* add actions to execute to menu */
GdaDataModelIter *iter;
TConnection *tcnc = NULL;
tcnc = get_t_connection (formgrid);
if (!tcnc)
return;
iter = gdaui_data_selector_get_data_set (GDAUI_DATA_SELECTOR (formgrid->priv->raw_grid));
/* actions */
GSList *actions_list, *list;
actions_list = t_favorites_actions_get (t_connection_get_favorites (tcnc),
tcnc, GDA_SET (iter));
if (actions_list) {
GtkWidget *mitem, *submenu;
mitem = gtk_menu_item_new_with_label (_("Execute action"));
gtk_widget_show (mitem);
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), mitem);
submenu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (mitem), submenu);
for (list = actions_list; list; list = list->next) {
TFavoritesAction *act = (TFavoritesAction*) list->data;
mitem = gtk_menu_item_new_with_label (act->name);
gtk_widget_show (mitem);
gtk_menu_shell_append (GTK_MENU_SHELL (submenu), mitem);
g_object_set_data_full (G_OBJECT (mitem), "action", act,
(GDestroyNotify) t_favorites_action_free);
g_signal_connect (mitem, "activate",
G_CALLBACK (execute_action_mitem_cb), formgrid);
}
g_slist_free (actions_list);
}
#ifdef HAVE_LDAP
/* LDAP specific */
if (t_connection_is_ldap (tcnc)) {
GdaHolder *dnh;
dnh = gda_set_get_holder (GDA_SET (iter), "dn");
if (dnh) {
const GValue *cvalue;
cvalue = gda_holder_get_value (GDA_HOLDER (dnh));
if (!cvalue && (G_VALUE_TYPE (cvalue) != G_TYPE_STRING))
dnh = NULL;
}
if (!dnh) {
GSList *list;
for (list = GDA_SET (iter)->holders; list; list = list->next) {
const GValue *cvalue;
cvalue = gda_holder_get_value (GDA_HOLDER (list->data));
if (cvalue && (G_VALUE_TYPE (cvalue) == G_TYPE_STRING) &&
gda_ldap_is_dn (g_value_get_string (cvalue))) {
dnh = GDA_HOLDER (list->data);
break;
}
}
}
if (dnh) {
const GValue *cvalue;
cvalue = gda_holder_get_value (dnh);
GtkWidget *mitem;
mitem = gtk_menu_item_new_with_label (_("View LDAP entry's details"));
gtk_widget_show (mitem);
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), mitem);
g_object_set_data_full (G_OBJECT (mitem), "dn",
g_value_dup_string (cvalue), g_free);
g_signal_connect (mitem, "activate",
G_CALLBACK (ldap_view_dn_mitem_cb), formgrid);
}
}
#endif
if (wid == formgrid->priv->raw_form) {
GtkWidget *mitem;
gboolean add_scale;
g_object_get (G_OBJECT (formgrid->priv->overlay_form), "add-scale", &add_scale, NULL);
mitem = gtk_check_menu_item_new_with_label (_("Zoom..."));
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mitem), add_scale);
gtk_widget_show (mitem);
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), mitem);
g_signal_connect (mitem, "toggled",
G_CALLBACK (zoom_form_mitem_cb), formgrid);
}
else if (wid == formgrid->priv->raw_grid) {
GtkWidget *mitem;
gboolean add_scale;
g_object_get (G_OBJECT (formgrid->priv->overlay_grid), "add-scale", &add_scale, NULL);
mitem = gtk_check_menu_item_new_with_label (_("Zoom..."));
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mitem), add_scale);
gtk_widget_show (mitem);
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), mitem);
g_signal_connect (mitem, "toggled",
G_CALLBACK (zoom_grid_mitem_cb), formgrid);
}
}
/**
* gda_batch_get_parameters:
* @batch: a #GdaBatch object
* @out_params: (out) (transfer full) (allow-none): a place to store a new #GdaSet object, or %NULL
* @error: a place to store errors, or %NULL
*
* Get a new #GdaSet object which groups all the execution parameters
* which @batch needs for all the statements it includes.
* This new object is returned though @out_params.
*
* Note that if @batch does not need any parameter, then @out_params is set to %NULL.
*
* Returns: TRUE if no error occurred.
*/
gboolean
gda_batch_get_parameters (GdaBatch *batch, GdaSet **out_params, GError **error)
{
GdaSet *set = NULL;
GSList *list;
g_return_val_if_fail (GDA_IS_BATCH (batch), FALSE);
g_return_val_if_fail (batch->priv, FALSE);
if (out_params)
*out_params = NULL;
if (!batch->priv->statements)
return TRUE;
for (list = batch->priv->statements; list; list = list->next) {
GdaSet *tmpset = NULL;
if (!gda_statement_get_parameters (GDA_STATEMENT (list->data), out_params ? &tmpset : NULL, error)) {
if (tmpset)
g_object_unref (tmpset);
if (set)
g_object_unref (set);
return FALSE;
}
if (tmpset && tmpset->holders) {
if (!set) {
set = tmpset;
tmpset = NULL;
}
else {
/* merge @set and @tmp_set */
GSList *holders;
for (holders = tmpset->holders; holders; holders = holders->next) {
GdaHolder *holder = (GdaHolder *) holders->data;
if (! gda_set_add_holder (set, holder)) {
GdaHolder *eholder = gda_set_get_holder (set, gda_holder_get_id (holder));
if (!eholder ||
(gda_holder_get_g_type (eholder) != (gda_holder_get_g_type (holder)))) {
/* error */
g_set_error (error, GDA_BATCH_ERROR, GDA_BATCH_CONFLICTING_PARAMETER_ERROR,
_("Conflicting parameter '%s'"), gda_holder_get_id (holder));
g_object_unref (tmpset);
g_object_unref (set);
return FALSE;
}
}
}
}
}
if (tmpset)
g_object_unref (tmpset);
}
if (set) {
if (out_params)
*out_params = set;
else
g_object_unref (set);
}
return TRUE;
}
/**
* gda_tools_favorites_get_actions
* @bfav: a #ToolsFavorites
* @bcnc: a #BrowserConnection
* @set: a #GdaSet
*
* Get a list of #ToolsFavoriteAction which can be executed with the data in @set.
*
* Returns: a new list of #ToolsFavoriteAction, free list with gda_tools_favorites_free_actions()
*/
GSList *
gda_tools_favorites_get_actions (ToolsFavorites *bfav, BrowserConnection *bcnc, GdaSet *set)
{
GSList *fav_list, *list, *retlist = NULL;
g_return_val_if_fail (GDA_TOOLS_IS_FAVORITES (bfav), NULL);
g_return_val_if_fail (BROWSER_IS_CONNECTION (bcnc), NULL);
g_return_val_if_fail (!set || GDA_IS_SET (set), NULL);
fav_list = gda_tools_favorites_list (bfav, 0, GDA_TOOLS_FAVORITES_ACTIONS, -1, NULL);
if (! fav_list)
return NULL;
for (list = fav_list; list; list = list->next) {
ToolsFavoritesAttributes *fa = (ToolsFavoritesAttributes*) list->data;
ToolsFavoritesAttributes qfa;
if (! g_str_has_prefix (fa->contents, "QUERY")) {
g_warning ("Malformed action contents '%s', please report error to "
"http://bugzilla.gnome.org/ for the \"libgda\" product",
fa->contents);
continue;
}
if (gda_tools_favorites_get (bfav, atoi (fa->contents + 5), &qfa, NULL)) {
GdaSet *params;
GSList *plist;
GdaBatch *batch;
GdaStatement *stmt = NULL;
GdaSqlParser *parser;
const gchar *remain;
const GSList *stmt_list;
gint nb_bound = 0;
parser = browser_connection_create_parser (bcnc);
batch = gda_sql_parser_parse_string_as_batch (parser, qfa.contents, &remain, NULL);
g_object_unref (parser);
if (!batch) {
gda_tools_favorites_reset_attributes (&qfa);
continue;
}
stmt_list = gda_batch_get_statements (batch);
for (plist = (GSList*) stmt_list; plist; plist = plist->next) {
if (! gda_statement_is_useless (GDA_STATEMENT (plist->data))) {
if (stmt)
break;
else
stmt = g_object_ref (GDA_STATEMENT (plist->data));
}
}
g_object_unref (batch);
if (!stmt || plist) {
gda_tools_favorites_reset_attributes (&qfa);
continue;
}
if (! gda_statement_get_parameters (stmt, ¶ms, NULL) || !params) {
g_object_unref (stmt);
gda_tools_favorites_reset_attributes (&qfa);
continue;
}
browser_connection_define_ui_plugins_for_stmt (bcnc, stmt, params);
for (plist = params->holders; plist; plist = plist->next) {
/* try to find holder in @set */
GdaHolder *req_holder, *in_holder;
req_holder = GDA_HOLDER (plist->data);
in_holder = gda_set_get_holder (set, gda_holder_get_id (req_holder));
if (in_holder && gda_holder_set_bind (req_holder, in_holder, NULL)) {
/* bound this holder to the oune found */
nb_bound++;
}
}
if (nb_bound > 0) {
/* at least 1 holder was found=> keep the action */
ToolsFavoriteAction *act;
act = g_new0 (ToolsFavoriteAction, 1);
retlist = g_slist_insert_sorted (retlist, act,
(GCompareFunc) actions_sort_func);
act->params = g_object_ref (params);
act->id = fa->id;
act->name = g_strdup (fa->name);
act->stmt = g_object_ref (stmt);
act->nb_bound = nb_bound;
/*g_print ("Action identified: ID=%d Bound=%d name=[%s] SQL=[%s]\n",
act->id, act->nb_bound,
act->name, qfa.contents);*/
}
g_object_unref (stmt);
g_object_unref (params);
gda_tools_favorites_reset_attributes (&qfa);
}
}
gda_tools_favorites_free_list (fav_list);
return retlist;
}
/*
* value_to_node
*
* Converts @value to a string
*/
static xmlNodePtr
value_to_node (GdaReportEngine *engine, G_GNUC_UNUSED RunContext *context, const GValue *value, GdaSet *options)
{
xmlNodePtr retnode = NULL;
GdaHolder *converter = NULL;
if (options)
converter = gda_set_get_holder (options, "converter");
if (!value || gda_value_is_null (value))
retnode = xmlNewText (BAD_CAST "");
else if ((G_VALUE_TYPE (value) == GDA_TYPE_BINARY) ||
(G_VALUE_TYPE (value) == GDA_TYPE_BLOB)) {
TO_IMPLEMENT;
retnode = xmlNewText (BAD_CAST _("Binary data"));
}
else {
GdaDataHandler *dh;
gchar *str;
if (!data_handlers) {
/* initialize the internal data handlers */
data_handlers = g_hash_table_new_full (gtype_hash, gtype_equal,
NULL, (GDestroyNotify) g_object_unref);
g_hash_table_insert (data_handlers, (gpointer) G_TYPE_INT64, gda_handler_numerical_new ());
g_hash_table_insert (data_handlers, (gpointer) G_TYPE_UINT64, gda_handler_numerical_new ());
g_hash_table_insert (data_handlers, (gpointer) G_TYPE_BOOLEAN, gda_handler_boolean_new ());
g_hash_table_insert (data_handlers, (gpointer) G_TYPE_DATE, gda_handler_time_new ());
g_hash_table_insert (data_handlers, (gpointer) G_TYPE_DOUBLE, gda_handler_numerical_new ());
g_hash_table_insert (data_handlers, (gpointer) G_TYPE_INT, gda_handler_numerical_new ());
g_hash_table_insert (data_handlers, (gpointer) GDA_TYPE_NUMERIC, gda_handler_numerical_new ());
g_hash_table_insert (data_handlers, (gpointer) G_TYPE_FLOAT, gda_handler_numerical_new ());
g_hash_table_insert (data_handlers, (gpointer) GDA_TYPE_SHORT, gda_handler_numerical_new ());
g_hash_table_insert (data_handlers, (gpointer) GDA_TYPE_USHORT, gda_handler_numerical_new ());
g_hash_table_insert (data_handlers, (gpointer) G_TYPE_STRING, gda_handler_string_new ());
g_hash_table_insert (data_handlers, (gpointer) GDA_TYPE_TIME, gda_handler_time_new ());
g_hash_table_insert (data_handlers, (gpointer) GDA_TYPE_TIMESTAMP, gda_handler_time_new ());
g_hash_table_insert (data_handlers, (gpointer) G_TYPE_CHAR, gda_handler_numerical_new ());
g_hash_table_insert (data_handlers, (gpointer) G_TYPE_UCHAR, gda_handler_numerical_new ());
g_hash_table_insert (data_handlers, (gpointer) G_TYPE_ULONG, gda_handler_numerical_new ());
g_hash_table_insert (data_handlers, (gpointer) G_TYPE_LONG, gda_handler_numerical_new ());
g_hash_table_insert (data_handlers, (gpointer) G_TYPE_GTYPE, gda_handler_type_new ());
g_hash_table_insert (data_handlers, (gpointer) G_TYPE_UINT, gda_handler_numerical_new ());
}
gboolean converted = FALSE;
dh = g_hash_table_lookup (data_handlers, (gpointer) G_VALUE_TYPE (value));
if (dh)
str = gda_data_handler_get_str_from_value (dh, value);
else
str = gda_value_stringify (value);
if (converter) {
const GValue *cvalue;
cvalue = gda_holder_get_value (converter);
if ((G_VALUE_TYPE (cvalue) == G_TYPE_STRING) && g_value_get_string (cvalue)) {
gchar **array;
array = g_strsplit (g_value_get_string (cvalue), "::", 0);
if (array[0] && !strcmp (array[0], "richtext")) {
if (array[1] && !strcmp (array[1], "docbook")) {
retnode = xmlNewNode (NULL, BAD_CAST "para");
parse_rich_text_to_docbook (engine, retnode, str);
converted = TRUE;
}
else if (array[1] && !strcmp (array[1], "html")) {
retnode = xmlNewNode (NULL, BAD_CAST "p");
parse_rich_text_to_html (engine, retnode, str);
converted = TRUE;
}
}
}
}
if (!converted)
retnode = xmlNewText (BAD_CAST (str ? str : ""));
g_free (str);
}
return retnode;
}
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;
}
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;
}
