static GdaSet *
make_options_set_from_string (const gchar *context, GdaSet *options)
{
GdaSet *expopt = NULL;
GSList *list, *nlist = NULL;
if (options) {
for (list = options->holders; list; list = list->next) {
GdaHolder *param = GDA_HOLDER (list->data);
const GValue *cvalue;
cvalue = gda_holder_get_attribute (param, context);
if (!cvalue)
continue;
GdaHolder *nparam;
const GValue *cvalue2;
cvalue2 = gda_holder_get_value (param);
nparam = gda_holder_new (G_VALUE_TYPE (cvalue2));
g_object_set ((GObject*) nparam, "id", g_value_get_string (cvalue), NULL);
g_assert (gda_holder_set_value (nparam, cvalue2, NULL));
nlist = g_slist_append (nlist, nparam);
}
if (nlist) {
expopt = gda_set_new (nlist);
g_slist_free (nlist);
}
}
return expopt;
}
/*
* assign_parameters_values
*
* Tries to assign a value for each parameter in @plist, from the context
*
* Returns: TRUE on success
*/
static gboolean
assign_parameters_values (GdaReportEngine *engine, RunContext *context, GdaSet *plist, GError **error)
{
if (plist) {
GSList *list;
for (list = plist->holders; list; list = list->next) {
GdaHolder *source_param;
source_param = run_context_find_param (engine, context,
BAD_CAST gda_holder_get_id (GDA_HOLDER (list->data)));
if (!source_param) {
g_set_error (error, 0, 0,
_("Unknown parameter '%s'"),
gda_holder_get_id (GDA_HOLDER (list->data)));
return FALSE;
}
gda_holder_set_not_null (GDA_HOLDER (list->data), FALSE);
GType ptype, source_ptype;
ptype = gda_holder_get_g_type (GDA_HOLDER (list->data));
source_ptype = gda_holder_get_g_type (source_param);
if (ptype == source_ptype) {
if (! gda_holder_set_bind (GDA_HOLDER (list->data), source_param, error))
return FALSE;
}
else {
const GValue *source_value;
source_value = gda_holder_get_value (source_param);
if (source_value && !gda_value_is_null (source_value)) {
GValue *trans;
trans = gda_value_new (ptype);
if (g_value_transform (source_value, trans)) {
if (! gda_holder_set_value (GDA_HOLDER (list->data), trans, error)) {
gda_value_free (trans);
return FALSE;
}
gda_value_free (trans);
}
else {
gda_value_free (trans);
g_set_error (error, 0, 0,
_("Cannot cast parameter from type '%s' to type '%s'"),
g_type_name (source_ptype), g_type_name (ptype));
return FALSE;
}
}
else
if (! gda_holder_set_value (GDA_HOLDER (list->data), NULL, error))
return FALSE;
}
}
}
return TRUE;
}
static gchar *
params_to_string (GdauiProviderAuthEditor *auth)
{
GString *string = NULL;
gchar *str;
GdaSet *dset;
GSList *list;
g_assert (auth->priv->auth_widget);
if (! GDAUI_IS_BASIC_FORM (auth->priv->auth_widget))
return NULL;
dset = gdaui_basic_form_get_data_set (GDAUI_BASIC_FORM (auth->priv->auth_widget));
for (list = dset->holders; list; list = list->next) {
GdaHolder *param = GDA_HOLDER (list->data);
if (gda_holder_is_valid (param)) {
const GValue *value;
value = gda_holder_get_value (param);
str = NULL;
if (value && !gda_value_is_null ((GValue *) value)) {
GdaDataHandler *dh;
GType dtype;
dtype = gda_holder_get_g_type (param);
dh = gda_data_handler_get_default (dtype);
str = gda_data_handler_get_str_from_value (dh, value);
}
if (str && *str) {
gchar *name;
gchar *ename, *evalue;
if (!string)
string = g_string_new ("");
else
g_string_append_c (string, ';');
g_object_get (G_OBJECT (list->data), "id", &name, NULL);
ename = gda_rfc1738_encode (name);
evalue = gda_rfc1738_encode (str);
g_string_append_printf (string, "%s=%s", ename, evalue);
g_free (ename);
g_free (evalue);
}
g_free (str);
}
}
str = string ? string->str : NULL;
if (string)
g_string_free (string, FALSE);
return str;
}
static void
dump_iter (GdaDataModelIter *iter)
{
GdaSet *set;
GSList *list;
set = GDA_SET (iter);
g_print ("Dump of GdaDataModelIter %p, @row %d\n", set, gda_data_model_iter_get_row (iter));
for (list = set->holders; list; list = list->next) {
GdaHolder *h = GDA_HOLDER (list->data);
gchar *str;
const GValue *cvalue;
cvalue = gda_holder_get_value (h);
str = gda_value_stringify (cvalue);
g_print (" [%s] type: %s value:[%s]\n", gda_holder_get_id (h),
gda_g_type_to_string (gda_holder_get_g_type (h)), str);
g_free (str);
}
}
/*
* COMMAND: <gda_report_param_value>
*
* Creates a new text node containing the value of the parameter named from "param_name"
*
* uses node's contents: no
* requested attributes: param_name
* optional attributes: converter => use "richtext::docbook"
*/
static gboolean
command_gda_report_param_value (GdaReportEngine *engine, xmlNodePtr node, GSList **created_nodes,
RunContext *context, GError **error)
{
xmlChar *prop;
prop = xmlGetProp (node, BAD_CAST "param_name");
if (prop) {
GdaHolder *param;
param = run_context_find_param (engine, context, prop);
if (!param) {
g_set_error (error, 0, 0,
_("Unknown parameter '%s'"), prop);
return FALSE;
}
else {
/* Add a text node */
const GValue *value;
xmlNodePtr child;
GdaSet *options = NULL;
xmlChar *cprop;
cprop = xmlGetProp (node, BAD_CAST "converter");
if (cprop) {
options = gda_set_new_inline (1, "converter", G_TYPE_STRING, (gchar*) cprop);
xmlFree (cprop);
}
value = gda_holder_get_value (param);
child = value_to_node (engine, context, value, options);
if (options)
g_object_unref (options);
*created_nodes = g_slist_prepend (NULL, child);
}
xmlFree (prop);
return TRUE;
}
else {
g_set_error (error, 0, 0, "%s",
_("Parameter name not specified"));
return FALSE;
}
}
static GdaRow *
create_new_row (GdaDataAccessWrapper *model)
{
gint i;
GdaRow *row;
row = gda_row_new (model->priv->nb_cols);
for (i = 0; i < model->priv->nb_cols; i++) {
GdaHolder *holder;
GValue *dest;
dest = gda_row_get_value (row, i);
if (model->priv->rows_mapping)
holder = gda_set_get_nth_holder ((GdaSet *) model->priv->iter, model->priv->rows_mapping [i]);
else
holder = gda_set_get_nth_holder ((GdaSet *) model->priv->iter, i);
if (holder) {
const GValue *cvalue = gda_holder_get_value (holder);
if (cvalue) {
gda_value_reset_with_type (dest, G_VALUE_TYPE ((GValue *) cvalue));
g_value_copy (cvalue, dest);
}
else
gda_value_set_null (dest);
}
else
gda_row_invalidate_value (row, dest);
}
gint *ptr;
ptr = g_new (gint, 1);
*ptr = model->priv->iter_row;
g_hash_table_insert (model->priv->rows, ptr, row);
/*g_print ("%s(%d)\n", __FUNCTION__, model->priv->iter_row);*/
return row;
}
/*
* 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 GSList *
gda_tree_mgr_select_update_children (GdaTreeManager *manager, GdaTreeNode *node,
G_GNUC_UNUSED const GSList *children_nodes, gboolean *out_error,
GError **error)
{
GdaTreeMgrSelect *mgr = GDA_TREE_MGR_SELECT (manager);
GdaDataModel *model;
GSList *list = NULL;
if (!mgr->priv->cnc) {
g_set_error (error, GDA_TREE_MANAGER_ERROR, GDA_TREE_MANAGER_UNKNOWN_ERROR,
"%s", _("No connection specified"));
if (out_error)
*out_error = TRUE;
return NULL;
}
if (!mgr->priv->stmt) {
g_set_error (error, GDA_TREE_MANAGER_ERROR, GDA_TREE_MANAGER_UNKNOWN_ERROR,
"%s", _("No SELECT statement specified"));
if (out_error)
*out_error = TRUE;
return NULL;
}
if (node && mgr->priv->non_bound_params) {
/* looking for values in @node's attributes */
GSList *nbplist;
for (nbplist = mgr->priv->non_bound_params; nbplist; nbplist = nbplist->next) {
const GValue *cvalue;
GdaHolder *holder = (GdaHolder*) nbplist->data;
cvalue = gda_tree_node_fetch_attribute (node, gda_holder_get_id (holder));
if (cvalue) {
if (!gda_holder_set_value (holder, cvalue, error)) {
if (out_error)
*out_error = TRUE;
return NULL;
}
}
else {
g_set_error (error, GDA_TREE_MANAGER_ERROR, GDA_TREE_MANAGER_UNKNOWN_ERROR,
_("No value specified for parameter '%s'"), gda_holder_get_id (holder));
if (out_error)
*out_error = TRUE;
return NULL;
}
}
}
model = gda_connection_statement_execute_select (mgr->priv->cnc, mgr->priv->stmt, mgr->priv->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 = NULL;
const GValue *cvalue;
GSList *iholders;
for (iholders = GDA_SET (iter)->holders; iholders; iholders = iholders->next) {
GdaHolder *holder = (GdaHolder*) iholders->data;
if (!gda_holder_is_valid (holder) || !(cvalue = gda_holder_get_value (holder))) {
if (list) {
g_slist_foreach (list, (GFunc) g_object_unref, NULL);
g_slist_free (list);
}
if (out_error)
*out_error = TRUE;
g_set_error (error, GDA_TREE_MANAGER_ERROR, GDA_TREE_MANAGER_UNKNOWN_ERROR,
"%s", _("Unable to get iterator's value"));
return NULL;
}
if (!snode) {
gchar *str = gda_value_stringify (cvalue);
snode = gda_tree_manager_create_node (manager, node, str);
g_free (str);
list = g_slist_prepend (list, snode);
}
gda_tree_node_set_node_attribute (snode, g_strdup (gda_holder_get_id (holder)), cvalue, g_free);
}
}
if (iter)
g_object_unref (iter);
g_object_unref (model);
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);
}
static void
options_form_param_changed_cb (G_GNUC_UNUSED GdauiBasicForm *form, G_GNUC_UNUSED GdaHolder *param,
G_GNUC_UNUSED gboolean is_user_modif, TablePreferences *tpref)
{
GtkTreeIter iter;
if (tpref->priv->save_plugin_changes &&
gtk_combo_box_get_active_iter (GTK_COMBO_BOX (tpref->priv->plugins_combo), &iter)) {
GdauiPlugin *plugin;
GError *error = NULL;
GString *plugin_all = NULL;
gtk_tree_model_get (tpref->priv->plugins_model, &iter, PL_COLUMN_PLUGIN, &plugin, -1);
if (plugin) {
plugin_all = g_string_new (plugin->plugin_name);
if (tpref->priv->options_wid) {
GdaSet *plist;
GSList *list;
gboolean first = TRUE;
plist = gdaui_basic_form_get_data_set (GDAUI_BASIC_FORM (tpref->priv->options_wid));
for (list = plist->holders; list; list = list->next) {
GdaHolder *holder;
const GValue *cvalue;
gchar *str, *r1, *r2;
holder = GDA_HOLDER (list->data);
if (! gda_holder_is_valid (holder))
continue;
cvalue = gda_holder_get_value (holder);
if (G_VALUE_TYPE (cvalue) == GDA_TYPE_NULL)
continue;
if (first) {
g_string_append_c (plugin_all, ':');
first = FALSE;
}
else
g_string_append_c (plugin_all, ';');
str = gda_value_stringify (cvalue);
r1 = gda_rfc1738_encode (str);
g_free (str);
r2 = gda_rfc1738_encode (gda_holder_get_id (holder));
g_string_append_printf (plugin_all, "%s=%s", r2, r1);
g_free (r1);
g_free (r2);
}
}
}
g_signal_handlers_block_by_func (tpref->priv->columns_store,
G_CALLBACK (columns_model_row_changed_cb), tpref);
if (tpref->priv->current_table &&
tpref->priv->current_column &&
! browser_connection_set_table_column_attribute (tpref->priv->bcnc,
tpref->priv->current_table,
tpref->priv->current_column,
BROWSER_CONNECTION_COLUMN_PLUGIN,
plugin_all ? plugin_all->str : NULL,
&error)) {
TO_IMPLEMENT; /* FIXME: add a notice somewhere in the UI */
g_warning ("Error: %s\n", error && error->message ? error->message : _("No detail"));
g_clear_error (&error);
}
g_signal_handlers_unblock_by_func (tpref->priv->columns_store,
G_CALLBACK (columns_model_row_changed_cb), tpref);
if (plugin_all)
g_string_free (plugin_all, TRUE);
}
set_preview_widget (tpref);
}
static gboolean
compare_iter (GdaDataModelIter *iter, gint exp_row, const gchar **col_ids, const gchar **col_types,
const gchar **col_values)
{
GdaSet *set;
GSList *list;
gint i;
set = GDA_SET (iter);
if (gda_data_model_iter_get_row (iter) != exp_row) {
g_print ("Iter is at wrong row: got %d and expected %d\n",
gda_data_model_iter_get_row (iter), exp_row);
return FALSE;
}
if (!col_ids)
return TRUE;
for (i = 0, list = set->holders;
col_ids[i] && list;
i++, list = list->next) {
GdaHolder *h = GDA_HOLDER (list->data);
gchar *str;
const GValue *cvalue;
if (strcmp (col_ids[i], gda_holder_get_id (h))) {
g_print ("Wrong column %d ID: got [%s] and expected [%s]\n", i,
gda_holder_get_id (h), col_ids[i]);
return FALSE;
}
if (strcmp (col_types[i], gda_g_type_to_string (gda_holder_get_g_type (h)))) {
g_print ("Wrong column %d type: got [%s] and expected [%s]\n", i,
gda_g_type_to_string (gda_holder_get_g_type (h)),
col_types[i]);
return FALSE;
}
cvalue = gda_holder_get_value (h);
str = gda_value_stringify (cvalue);
if (strcmp (col_values[i], str)) {
g_print ("Wrong column %d value: got [%s] and expected [%s]\n", i,
str, col_values[i]);
g_free (str);
return FALSE;
}
g_free (str);
}
if (col_ids[i]) {
g_print ("Missing at least the [%s] column %d\n", col_ids[i], i);
return FALSE;
}
if (list) {
GdaHolder *h = GDA_HOLDER (list->data);
g_print ("Too much columns, at least [%s] column %d\n",
gda_holder_get_id (h), i);
return FALSE;
}
return TRUE;
}
gchar *
tests_common_holder_serialize (GdaHolder *h)
{
GString *string;
gchar *str, *json;
const GValue *value;
string = g_string_new ("{");
g_string_append (string, "\"type\":");
g_string_append_printf (string, "\"%s\"", g_type_name (gda_holder_get_g_type (h)));
g_string_append (string, ",\"id\":");
json = _json_quote_string (gda_holder_get_id (h));
g_string_append (string, json);
g_free (json);
g_object_get (G_OBJECT (h), "name", &str, NULL);
if (str) {
g_string_append (string, ",\"name\":");
json = _json_quote_string (str);
g_string_append (string, json);
g_free (json);
g_free (str);
}
g_object_get (G_OBJECT (h), "description", &str, NULL);
if (str) {
g_string_append (string, ",\"descr\":");
json = _json_quote_string (str);
g_string_append (string, json);
g_free (json);
g_free (str);
}
g_string_append (string, ",\"value\":");
value = gda_holder_get_value (h);
str = gda_value_stringify (value);
json = _json_quote_string (str);
g_free (str);
g_string_append (string, json);
g_free (json);
g_string_append (string, ",\"default_value\":");
value = gda_holder_get_default_value (h);
str = gda_value_stringify (value);
json = _json_quote_string (str);
g_free (str);
g_string_append (string, json);
g_free (json);
g_string_append (string, ",\"is_default\":");
g_string_append_printf (string, gda_holder_value_is_default (h) ? "\"TRUE\"" : "\"FALSE\"");
g_string_append (string, ",\"is_valid\":");
g_string_append_printf (string, gda_holder_is_valid (h) ? "\"TRUE\"" : "\"FALSE\"");
g_string_append (string, ",\"not_null\":");
g_string_append_printf (string, gda_holder_get_not_null (h) ? "\"TRUE\"" : "\"FALSE\"");
g_string_append_c (string, '}');
str = string->str;
g_string_free (string, FALSE);
return str;
}
/**
* base_tool_output_result_to_string:
* @res: a #ToolCommandResult
* @format: a #ToolOutputFormat format specification
* @stream: (allow-none): a stream which the returned string will be put to, or %NULL
* @options: (allow-none): a #GdaSet containing options, or %NULL
*
* Converts @res to a string
*
* Returns: (transfer full): a new string
*/
gchar *
base_tool_output_result_to_string (ToolCommandResult *res, ToolOutputFormat format,
FILE *stream, GdaSet *options)
{
switch (res->type) {
case BASE_TOOL_COMMAND_RESULT_DATA_MODEL:
return base_tool_output_data_model_to_string (res->u.model, format, stream, options);
case BASE_TOOL_COMMAND_RESULT_SET: {
GSList *list;
GString *string;
xmlNodePtr node;
xmlBufferPtr buffer;
gchar *str;
if (format & BASE_TOOL_OUTPUT_FORMAT_DEFAULT) {
string = g_string_new ("");
for (list = res->u.set->holders; list; list = list->next) {
const GValue *value;
gchar *tmp;
const gchar *cstr;
GdaHolder *h;
h = GDA_HOLDER (list->data);
cstr = gda_holder_get_id (h);
value = gda_holder_get_value (h);
if (!strcmp (cstr, "IMPACTED_ROWS")) {
g_string_append_printf (string, "%s: ",
_("Number of rows impacted"));
tmp = gda_value_stringify (value);
g_string_append_printf (string, "%s", tmp);
g_free (tmp);
}
else if (!strcmp (cstr, "EXEC_DELAY")) {
g_string_append_printf (string, "%s: ",
_("Execution delay"));
gdouble etime;
etime = g_value_get_double (value);
g_string_append_printf (string, "%.03f s", etime);
}
else {
tmp = g_markup_escape_text (cstr, -1);
g_string_append_printf (string, "%s: ", tmp);
g_free (tmp);
tmp = gda_value_stringify (value);
g_string_append_printf (string, "%s", tmp);
g_free (tmp);
}
g_string_append (string, "\n");
}
str = string->str;
g_string_free (string, FALSE);
return str;
}
else if (format & BASE_TOOL_OUTPUT_FORMAT_XML) {
buffer = xmlBufferCreate ();
node = xmlNewNode (NULL, BAD_CAST "parameters");
for (list = res->u.set->holders; list; list = list->next) {
const GValue *value;
xmlNodePtr pnode, vnode;
pnode = xmlNewNode (NULL, BAD_CAST "parameter");
xmlAddChild (node, pnode);
xmlSetProp (pnode, BAD_CAST "name",
BAD_CAST gda_holder_get_id (GDA_HOLDER (list->data)));
value = gda_holder_get_value (GDA_HOLDER (list->data));
vnode = gda_value_to_xml (value);
xmlAddChild (pnode, vnode);
}
xmlNodeDump (buffer, NULL, node, 0, 1);
str = g_strdup ((gchar *) xmlBufferContent (buffer));
xmlBufferFree (buffer);
xmlFreeNode (node);
return str;
}
else if (format & BASE_TOOL_OUTPUT_FORMAT_HTML) {
buffer = xmlBufferCreate ();
node = xmlNewNode (NULL, BAD_CAST "ul");
for (list = res->u.set->holders; list; list = list->next) {
const GValue *value;
xmlNodePtr pnode, vnode;
pnode = xmlNewNode (NULL, BAD_CAST "li");
xmlAddChild (node, pnode);
xmlSetProp (pnode, BAD_CAST "name",
BAD_CAST gda_holder_get_id (GDA_HOLDER (list->data)));
value = gda_holder_get_value (GDA_HOLDER (list->data));
vnode = gda_value_to_xml (value);
xmlAddChild (pnode, vnode);
}
xmlNodeDump (buffer, NULL, node, 0, 1);
str = g_strdup ((gchar *) xmlBufferContent (buffer));
xmlBufferFree (buffer);
xmlFreeNode (node);
return str;
}
else if (format & BASE_TOOL_OUTPUT_FORMAT_CSV) {
string = g_string_new ("");
for (list = res->u.set->holders; list; list = list->next) {
const GValue *value;
gchar *tmp;
const gchar *cstr;
GdaHolder *h;
h = GDA_HOLDER (list->data);
cstr = gda_holder_get_id (h);
value = gda_holder_get_value (h);
if (!strcmp (cstr, "IMPACTED_ROWS")) {
g_string_append_printf (string, "\"%s\",",
_("Number of rows impacted"));
tmp = gda_value_stringify (value);
g_string_append_printf (string, "\"%s\"", tmp);
g_free (tmp);
}
else if (!strcmp (cstr, "EXEC_DELAY")) {
g_string_append_printf (string, "\"%s\",",
_("Execution delay"));
gdouble etime;
etime = g_value_get_double (value);
g_string_append_printf (string, "\"%.03f s\"", etime);
}
else {
tmp = g_markup_escape_text (cstr, -1);
g_string_append_printf (string, "\"%s\",", tmp);
g_free (tmp);
tmp = gda_value_stringify (value);
g_string_append_printf (string, "\"%s\"", tmp);
g_free (tmp);
}
g_string_append (string, "\n");
}
str = string->str;
g_string_free (string, FALSE);
return str;
}
else {
TO_IMPLEMENT;
return NULL;
}
}
case BASE_TOOL_COMMAND_RESULT_TREE: {
GdaSet *options2, *merge = NULL;
options2 = g_object_get_data ((GObject*) res->u.tree, "BASE_TOOL_OUTPUT_OPTIONS");
if (options && options2) {
merge = gda_set_copy (options2);
gda_set_merge_with_set (merge, options);
}
gchar *tmp;
tmp = tree_to_string (res->u.tree, format, stream, merge ? merge : (options ? options : options2));
if (merge)
g_object_unref (merge);
return tmp;
}
case BASE_TOOL_COMMAND_RESULT_TXT: {
xmlNodePtr node;
xmlBufferPtr buffer;
gchar *str;
if ((format & BASE_TOOL_OUTPUT_FORMAT_DEFAULT) ||
(format & BASE_TOOL_OUTPUT_FORMAT_CSV))
return g_strdup (res->u.txt->str);
else if (format & BASE_TOOL_OUTPUT_FORMAT_XML) {
buffer = xmlBufferCreate ();
node = xmlNewNode (NULL, BAD_CAST "txt");
xmlNodeSetContent (node, BAD_CAST res->u.txt->str);
xmlNodeDump (buffer, NULL, node, 0, 1);
str = g_strdup ((gchar *) xmlBufferContent (buffer));
xmlBufferFree (buffer);
xmlFreeNode (node);
return str;
}
else if (format & BASE_TOOL_OUTPUT_FORMAT_HTML) {
buffer = xmlBufferCreate ();
node = xmlNewNode (NULL, BAD_CAST "p");
xmlNodeSetContent (node, BAD_CAST res->u.txt->str);
xmlNodeDump (buffer, NULL, node, 0, 1);
str = g_strdup ((gchar *) xmlBufferContent (buffer));
xmlBufferFree (buffer);
xmlFreeNode (node);
return str;
}
else {
TO_IMPLEMENT;
return NULL;
}
}
case BASE_TOOL_COMMAND_RESULT_EMPTY:
return g_strdup ("");
case BASE_TOOL_COMMAND_RESULT_MULTIPLE: {
GSList *list;
GString *string = NULL;
gchar *str;
for (list = res->u.multiple_results; list; list = list->next) {
ToolCommandResult *tres = (ToolCommandResult*) list->data;
gchar *tmp;
tmp = base_tool_output_result_to_string (tres,
format & BASE_TOOL_OUTPUT_FORMAT_COLOR_TERM ? TRUE : FALSE,
stream, options);
if (!string)
string = g_string_new (tmp);
else {
g_string_append_c (string, '\n');
g_string_append (string, tmp);
}
g_free (tmp);
}
if (string) {
str = string->str;
g_string_free (string, FALSE);
}
else
str = g_strdup ("");
return str;
}
case BASE_TOOL_COMMAND_RESULT_HELP: {
if (format & BASE_TOOL_OUTPUT_FORMAT_XML) {
xmlBufferPtr buffer;
gchar *str;
buffer = xmlBufferCreate ();
xmlNodeDump (buffer, NULL, res->u.xml_node, 0, 1);
str = g_strdup ((gchar *) xmlBufferContent (buffer));
xmlBufferFree (buffer);
return str;
}
else if (format & BASE_TOOL_OUTPUT_FORMAT_HTML) {
TO_IMPLEMENT;
return NULL;
}
else {
gint width = -1;
gboolean term_color;
if (format & BASE_TOOL_OUTPUT_FORMAT_DEFAULT)
base_tool_input_get_size (&width, NULL);
term_color = format & BASE_TOOL_OUTPUT_FORMAT_COLOR_TERM ? TRUE : FALSE;
return base_tool_help_to_string (res, width, term_color);
}
break;
}
default:
g_assert_not_reached ();
return NULL;
}
}
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);
}
}
static void
extract_named_parameters (GdaServerOperation *op, const gchar *root_path, GtkTextBuffer *tbuffer)
{
GdaServerOperationNode *node;
GtkTextIter iter;
gchar *str;
node = gda_server_operation_get_node_info (op, root_path);
g_return_if_fail (node);
gtk_text_buffer_get_end_iter (tbuffer, &iter);
gtk_text_buffer_insert (tbuffer, &iter, " * ", -1);
if (node->status == GDA_SERVER_OPERATION_STATUS_REQUIRED)
gtk_text_buffer_insert_with_tags_by_name (tbuffer, &iter, root_path, -1, "req_pathname", NULL);
else
gtk_text_buffer_insert_with_tags_by_name (tbuffer, &iter, root_path, -1, "opt_pathname", NULL);
gtk_text_buffer_insert (tbuffer, &iter, " (", -1);
switch (node->type) {
case GDA_SERVER_OPERATION_NODE_PARAMLIST: {
GSList *params;
str = g_strdup_printf ("GdaSet @%p)\n", node->plist);
gtk_text_buffer_insert (tbuffer, &iter, str, -1);
g_free (str);
for (params = node->plist->holders; params; params = params->next) {
gchar *npath;
npath = g_strdup_printf ("%s/%s", root_path, gda_holder_get_id (GDA_HOLDER (params->data)));
extract_named_parameters (op, npath, tbuffer);
g_free (npath);
}
break;
}
case GDA_SERVER_OPERATION_NODE_DATA_MODEL: {
gint i, ncols;
str = g_strdup_printf ("GdaDataModel @%p)\n", node->model);
gtk_text_buffer_insert (tbuffer, &iter, str, -1);
g_free (str);
ncols = gda_data_model_get_n_columns (node->model);
for (i = 0; i < ncols; i++) {
GdaColumn *col = gda_data_model_describe_column (node->model, i);
gchar *npath, *str;
g_object_get (G_OBJECT (col), "id", &str, NULL);
npath = g_strdup_printf ("%s/@%s", root_path, str);
g_free (str);
extract_named_parameters (op, npath, tbuffer);
g_free (npath);
}
break;
}
case GDA_SERVER_OPERATION_NODE_PARAM: {
gchar *str;
const GValue *value;
gtk_text_buffer_insert (tbuffer, &iter, "GdaHolder) = ", -1);
value = gda_holder_get_value (node->param);
str = gda_value_stringify (value);
gtk_text_buffer_insert (tbuffer, &iter, str, -1);
gtk_text_buffer_insert (tbuffer, &iter, "\n", -1);
g_free (str);
break;
}
case GDA_SERVER_OPERATION_NODE_SEQUENCE: {
gtk_text_buffer_insert (tbuffer, &iter, "Sequence)\n", -1);
guint i, size = gda_server_operation_get_sequence_size (op, root_path);
for (i = 0; i < size; i++) {
gchar **names;
names = gda_server_operation_get_sequence_item_names (op, root_path);
guint n;
for (n = 0; names [n]; n++) {
gchar *npath;
npath = g_strdup_printf ("%s/%u%s", root_path, i, names [n]);
extract_named_parameters (op, npath, tbuffer);
g_free (npath);
}
g_strfreev (names);
}
break;
}
case GDA_SERVER_OPERATION_NODE_SEQUENCE_ITEM:
gtk_text_buffer_insert (tbuffer, &iter, "Sequence item)\n", -1);
break;
case GDA_SERVER_OPERATION_NODE_DATA_MODEL_COLUMN: {
gint j, nrows;
gtk_text_buffer_insert (tbuffer, &iter, "Model column)\n", -1);
nrows = gda_data_model_get_n_rows (node->model);
for (j = 0; j < nrows; j++) {
gchar *npath, *str;
const GValue *value;
npath = g_strdup_printf ("%s/%d", root_path, j);
value = gda_data_model_get_value_at (node->model, gda_column_get_position (node->column), j, NULL);
if (value)
str = gda_value_stringify (value);
else
str = g_strdup ("Error: could not read data model's value");
gtk_text_buffer_insert (tbuffer, &iter, " * ", -1);
gtk_text_buffer_insert_with_tags_by_name (tbuffer, &iter, npath, -1, "opt_pathname", NULL);
g_free (npath);
gtk_text_buffer_insert (tbuffer, &iter, " (GValue) = ", -1);
gtk_text_buffer_insert (tbuffer, &iter, str, -1);
gtk_text_buffer_insert (tbuffer, &iter, "\n", -1);
g_free (str);
}
break;
}
default:
gtk_text_buffer_insert (tbuffer, &iter, "???", -1);
break;
}
}
