void
tests_common_display_value (const gchar *prefix, const GValue *value)
{
gchar *str;
str = gda_value_stringify ((GValue*) value);
g_print ("*** %s: %s\n", prefix, str);
g_free (str);
}
void
dsn_config_delete (GtkWidget *dsn)
{
DsnConfigPrivate *priv;
GtkTreeSelection *sel;
GList *list, *sel_rows;
GList *sel_dsn = NULL;
GdaDataModel *model;
priv = g_object_get_data (G_OBJECT (dsn), DSN_CONFIG_DATA);
sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->dsn_list));
sel_rows = gtk_tree_selection_get_selected_rows (sel, NULL);
model = gdaui_data_selector_get_model (GDAUI_DATA_SELECTOR (priv->dsn_list));
g_assert (GDA_IS_DATA_MODEL (model));
/* make a list of DSN to remove */
for (list = sel_rows; list; list = list->next) {
gchar *dsn;
gint *row;
const GValue *cvalue;
row = gtk_tree_path_get_indices ((GtkTreePath *) list->data);
cvalue = gda_data_model_get_value_at (model, 0, *row, NULL);
if (cvalue) {
dsn = gda_value_stringify ((GValue *) cvalue);
sel_dsn = g_list_prepend (sel_dsn, dsn);
}
gtk_tree_path_free ((GtkTreePath *) list->data);
}
g_list_free (sel_rows);
/* actually remove the DSN listed */
for (list = sel_dsn; list; list = list->next) {
gchar *str, *dsn;
GtkWidget *dialog;
dsn = (gchar *) list->data;
str = g_strdup_printf (_("Are you sure you want to remove the data source '%s'?"), dsn);
dialog = gtk_message_dialog_new_with_markup (GTK_WINDOW (gtk_widget_get_toplevel (priv->dsn_list)),
GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION,
GTK_BUTTONS_YES_NO,
"<b>%s:</b>\n\n%s",
_("Data source removal confirmation"), str);
g_free (str);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_NO);
gtk_widget_show (dialog);
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_YES)
gda_config_remove_dsn (dsn, NULL);
gtk_widget_destroy (dialog);
g_free (dsn);
}
}
static VALUE rb_cExpr_value(VALUE self)
{
GdaSqlExpr * st;
GValue * val;
Data_Get_Struct(self, GdaSqlExpr, st);
val = st->value;
return rb_str_new2(gda_value_stringify(val));
}
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);
}
}
/**
* Helper to get an int.
*/
static gint
get_int (GdaDataModel *res, gint row, gint column)
{
gchar *str;
GValue *value;
gint i;
value = (GValue *) gda_data_model_get_value_at (res, column, row);
if (value == NULL) {
g_warning ("Failed to get a value: (%d,%d)", column, row);
return INT_MAX;
}
str = gda_value_stringify (value);
i = strtol (str, NULL, 10);
g_free (str);
return i;
}
/**
* oseaserver_command_get_dataset:
* @datamodel: A GdaDataModel to extract data from.
*
* Convenienve function to translate a given @datamodel into a
* CoyoteDataSet structure.
*
* Return value: A translated CoyoteDataSet or NULL if fails.
**/
CoyoteDataSet * oseaserver_command_get_dataset (GdaDataModel * datamodel)
{
gint rows, columns, i, j;
CoyoteDataSet * result;
GdaValue * value = NULL;
gchar * str_value = NULL;
g_return_val_if_fail (datamodel, NULL);
rows = gda_data_model_get_n_rows (datamodel);
columns = gda_data_model_get_n_columns (datamodel);
result = coyote_dataset_new ();
for (i = 0; i < rows; i++) {
for (j = 0; j < columns; j ++) {
value = gda_value_copy ( gda_data_model_get_value_at (datamodel, j, i) );
str_value = gda_value_stringify (value);
coyote_dataset_add (result, str_value);
g_free (str_value);
if (value->type != GDA_VALUE_TYPE_NUMERIC)
gda_value_free (value);
else {
#warning We must remove this if when gda fix its gda_value_copy bug
}
}
if (i == (rows - 1))
break;
coyote_dataset_new_row (result);
}
return result;
}
/**
* Helper to get an UTF-8 string.
*/
static gchar *
get_string (GdaDataModel *res, gint row, gint column)
{
gchar *str;
gchar *ret;
gsize len;
GValue *value;
value = (GValue *) gda_data_model_get_value_at (res, column, row);
if (value == NULL) {
g_warning ("Failed to get a value: (%d,%d)", column, row);
return "";
}
str = gda_value_stringify (value);
len = strlen (str);
if (g_utf8_validate (str, len, NULL)) {
return str;
}
/* First, try to convert to UTF-8 from the current locale. */
ret = g_locale_to_utf8 (str, len, NULL, NULL, NULL);
if (!ret) {
/* If that fails, try to convert to UTF-8 from ISO-8859-1. */
ret = g_convert (str, len, "UTF-8", "ISO-8859-1", NULL, NULL, NULL);
}
if (!ret) {
/* Give up. */
ret = g_strdup (_("Invalid Unicode"));
}
g_free (str);
return ret;
}
void
sim_xml_config_set_config_max_event_tmp (SimConfig *config)
{
GdaDataModel *dm;
GdaValue *value;
gchar *query;
g_return_if_fail (config);
g_return_if_fail (SIM_IS_CONFIG (config));
query = g_strdup_printf ("SELECT value FROM config WHERE conf='max_event_tmp'");
dm = sim_database_execute_single_command (ossim.ossimdb, query);
if (dm)
{
value = (GdaValue *) gda_data_model_get_value_at (dm, 0, 0);
if (gda_data_model_get_n_rows(dm) !=0) //to avoid (null)-Critical: gda_value_is_null: assertion `value != NULL' failed
{
if (!gda_value_is_null (value))
{
config->max_event_tmp = gda_value_stringify (value);
}
else
g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "sim_xml_config_set_config_max_event_tmp value null");
}
else
config->max_event_tmp = 0;
}
else
{
g_message ("Error: Config DATA MODEL ERROR");
config->max_event_tmp = 0;
}
g_free (query);
}
BerValue *
gda_ldap_attr_g_value_to_value (LdapConnectionData *cdata, const GValue *cvalue)
{
BerValue *bv;
if (!cvalue)
return NULL;
bv = g_new (struct berval, 1);
if (G_VALUE_TYPE (cvalue) == G_TYPE_STRING) {
const gchar *cstr;
cstr = g_value_get_string (cvalue);
bv->bv_val = g_strdup (cstr);
bv->bv_len = strlen (cstr);
}
else if (G_VALUE_TYPE (cvalue) == G_TYPE_DATE_TIME) {
GDateTime *ts;
gchar *str;
ts = g_value_get_boxed (cvalue);
if (g_date_time_get_second (ts) == (gint) g_date_time_get_seconds (ts)) {
if (g_date_time_get_utc_offset (ts) == 0)
str = g_strdup_printf ("%04d-%02d-%02dT%02d:%02d:%02d",
g_date_time_get_year (ts),
g_date_time_get_month (ts),
g_date_time_get_day_of_month (ts),
g_date_time_get_hour (ts),
g_date_time_get_minute (ts),
g_date_time_get_second (ts));
else {
str = g_strdup_printf ("%04d-%02d-%02dT%02d:%02d:%02d",
g_date_time_get_year (ts),
g_date_time_get_month (ts),
g_date_time_get_day_of_month (ts),
g_date_time_get_hour (ts),
g_date_time_get_minute (ts),
g_date_time_get_second (ts));
TO_IMPLEMENT;
}
}
else {
if (g_date_time_get_utc_offset (ts) == 0)
str = g_strdup_printf ("%04d-%02d-%02dT%02d:%02d:%02d,%lu",
g_date_time_get_year (ts),
g_date_time_get_month (ts),
g_date_time_get_day_of_month (ts),
g_date_time_get_hour (ts),
g_date_time_get_minute (ts),
g_date_time_get_second (ts),
(gulong) ((g_date_time_get_seconds (ts) - g_date_time_get_second (ts)) * 1000000.0));
else {
str = g_strdup_printf ("%04d-%02d-%02dT%02d:%02d:%02d,%lu",
g_date_time_get_year (ts),
g_date_time_get_month (ts),
g_date_time_get_day_of_month (ts),
g_date_time_get_hour (ts),
g_date_time_get_minute (ts),
g_date_time_get_second (ts),
(gulong) ((g_date_time_get_seconds (ts) - g_date_time_get_second (ts)) * 1000000.0));
TO_IMPLEMENT;
}
}
bv->bv_val = str;
bv->bv_len = strlen (str);
}
else if (G_VALUE_TYPE (cvalue) == G_TYPE_DATE) {
GDate *date;
gchar *str;
date = (GDate*) g_value_get_boxed (cvalue);
str = g_strdup_printf ("%04d-%02d-%02d", g_date_get_year (date), g_date_get_month (date),
g_date_get_day (date));
bv->bv_val = str;
bv->bv_len = strlen (str);
}
else if (G_VALUE_TYPE (cvalue) == GDA_TYPE_NULL) {
bv->bv_val = NULL;
bv->bv_len = 0;
}
else if (G_VALUE_TYPE (cvalue) == GDA_TYPE_BINARY) {
TO_IMPLEMENT;
}
else if (G_VALUE_TYPE (cvalue) == GDA_TYPE_BLOB) {
TO_IMPLEMENT;
}
else {
gchar *str;
str = gda_value_stringify (cvalue);
bv->bv_val = str;
bv->bv_len = strlen (str);
}
return bv;
}
GdaOracleValue *
_gda_value_to_oracle_value (const GValue *value)
{
GdaOracleValue *ora_value;
OCIDate *oci_date;
GType type;
ora_value = g_new0 (GdaOracleValue, 1);
ora_value->g_type = G_VALUE_TYPE (value);
ora_value->indicator = 0;
ora_value->hdef = (OCIDefine *) 0;
ora_value->pard = (OCIParam *) 0;
type = ora_value->g_type;
if (type == GDA_TYPE_NULL)
ora_value->indicator = -1;
else if ((type == G_TYPE_INT64) ||
(type == G_TYPE_UINT64) ||
(type == G_TYPE_DOUBLE) ||
(type == G_TYPE_INT) ||
(type == G_TYPE_UINT) ||
(type == GDA_TYPE_NUMERIC) ||
(type == G_TYPE_FLOAT) ||
(type == GDA_TYPE_SHORT) ||
(type == GDA_TYPE_USHORT) ||
(type == G_TYPE_LONG) ||
(type == G_TYPE_ULONG) ||
(type == G_TYPE_CHAR) ||
(type == G_TYPE_UCHAR)) {
gchar *val_str;
val_str = gda_value_stringify ((GValue *) value);
if (!val_str)
return NULL;
ora_value->sql_type = SQLT_CHR;
ora_value->value = (void *) val_str;
ora_value->defined_size = strlen (val_str);
}
else if (type == G_TYPE_DATE) {
GDate *gda_date;
ora_value->sql_type = SQLT_ODT;
gda_date = (GDate*) g_value_get_boxed (value);
oci_date = g_new0(OCIDate, 1);
OCIDateSetDate(oci_date, gda_date->year, gda_date->month, gda_date->day);
ora_value->defined_size = sizeof (OCIDate);
ora_value->value = oci_date;
}
else if (type == GDA_TYPE_TIME) {
GdaTime *gda_time;
ora_value->sql_type = SQLT_ODT;
gda_time = (GdaTime *) gda_value_get_time ((GValue *) value);
oci_date = g_new0(OCIDate, 1);
OCIDateSetTime(oci_date, gda_time->hour, gda_time->minute, gda_time->second);
ora_value->defined_size = sizeof (OCIDate);
ora_value->value = oci_date;
}
else if (type == GDA_TYPE_TIMESTAMP) {
GdaTimestamp *gda_timestamp;
ora_value->sql_type = SQLT_ODT;
gda_timestamp = (GdaTimestamp *) gda_value_get_timestamp ((GValue *) value);
oci_date = g_new0(OCIDate, 1);
OCIDateSetDate(oci_date, gda_timestamp->year, gda_timestamp->month, gda_timestamp->day);
OCIDateSetTime(oci_date, gda_timestamp->hour, gda_timestamp->minute, gda_timestamp->second);
ora_value->defined_size = sizeof (OCIDate);
ora_value->value = oci_date;
}
else if (type == GDA_TYPE_BLOB) {
GdaBinary *bin;
bin = (GdaBinary *) gda_value_get_blob ((GValue *) value);
if (bin) {
ora_value->sql_type = SQLT_LNG;
ora_value->value = bin->data;
ora_value->defined_size = bin->binary_length;
}
else {
ora_value->sql_type = SQLT_CHR;
ora_value->value = g_strdup ("");
ora_value->defined_size = 0;
}
}
else if (type == GDA_TYPE_BINARY) {
GdaBinary *bin;
bin = (GdaBinary *) gda_value_get_binary ((GValue *) value);
if (bin) {
ora_value->sql_type = SQLT_LNG;
ora_value->value = bin->data;
ora_value->defined_size = bin->binary_length;
}
else {
ora_value->sql_type = SQLT_CHR;
ora_value->value = g_strdup ("");
ora_value->defined_size = 0;
}
}
else {
gchar *val_str;
val_str = gda_value_stringify ((GValue *) value);
if (!val_str)
return NULL;
ora_value->sql_type = SQLT_CHR;
ora_value->value = val_str;
ora_value->defined_size = strlen (val_str);
}
return ora_value;
}
static void
list_selection_changed_cb (GdauiRawGrid *grid, gpointer user_data)
{
DsnConfigPrivate *priv;
GdaDataModel *model;
GArray *selection;
gchar *str;
const GValue *cvalue;
GtkWidget *win = gtk_widget_get_toplevel (GTK_WIDGET (grid));
if (gtk_widget_is_toplevel (win)) {
g_simple_action_set_enabled (G_SIMPLE_ACTION (g_action_map_lookup_action (G_ACTION_MAP (win),
"DatasourceDelete")), FALSE);
}
priv = g_object_get_data (G_OBJECT (user_data), DSN_CONFIG_DATA);
selection = gdaui_data_selector_get_selected_rows (GDAUI_DATA_SELECTOR (priv->dsn_list));
if (!selection) {
gtk_stack_set_visible_child_name (GTK_STACK (priv->stack), ST_NOPROP);
return;
}
model = gdaui_data_selector_get_model (GDAUI_DATA_SELECTOR (priv->dsn_list));
if (!GDA_IS_DATA_MODEL (model)) {
g_array_free (selection, TRUE);
gtk_stack_set_visible_child_name (GTK_STACK (priv->stack), ST_NOPROP);
return;
}
cvalue = gda_data_model_get_value_at (model, 0, g_array_index (selection, gint, 0), NULL);
g_array_free (selection, TRUE);
if (!cvalue) {
gtk_stack_set_visible_child_name (GTK_STACK (priv->stack), ST_NOPROP);
return;
}
str = gda_value_stringify ((GValue *) cvalue);
g_print ("==> %s\n", str);
GdaDsnInfo *dsn_info;
dsn_info = gda_config_get_dsn_info (str);
g_free (str);
if (!dsn_info) {
/* something went wrong here... */
gtk_stack_set_visible_child_name (GTK_STACK (priv->stack), ST_NOPROP);
return;
}
gdaui_dsn_editor_set_dsn (priv->dsn_editor, dsn_info);
if (gdaui_dsn_editor_need_authentication (priv->dsn_editor))
gtk_widget_show (GTK_WIDGET (priv->view_buttons [GDAUI_DSN_EDITOR_PANE_AUTH]));
else
gtk_widget_hide (GTK_WIDGET (priv->view_buttons [GDAUI_DSN_EDITOR_PANE_AUTH]));
gtk_toggle_button_set_active (priv->view_buttons [GDAUI_DSN_EDITOR_PANE_DEFINITION], TRUE);
gtk_stack_set_visible_child_name (GTK_STACK (priv->stack), ST_PROP);
if (gtk_widget_is_toplevel (win)) {
g_simple_action_set_enabled (G_SIMPLE_ACTION (g_action_map_lookup_action (G_ACTION_MAP (win),
"DatasourceDelete")), TRUE);
}
}
static void
update_display (GdauiCloud *cloud)
{
GtkTextBuffer *tbuffer;
GtkTextIter start, end;
/* clean all */
tbuffer = cloud->priv->tbuffer;
gtk_text_buffer_get_start_iter (tbuffer, &start);
gtk_text_buffer_get_end_iter (tbuffer, &end);
gtk_text_buffer_delete (tbuffer, &start, &end);
if (cloud->priv->selected_tags) {
g_slist_foreach (cloud->priv->selected_tags, (GFunc) g_object_unref, NULL);
g_slist_free (cloud->priv->selected_tags);
cloud->priv->selected_tags = NULL;
sync_iter_with_selection (cloud);
g_signal_emit_by_name (cloud, "selection-changed");
}
if (!cloud->priv->model)
return;
if (cloud->priv->label_column < 0)
return;
/* check for the data model's column type */
GdaColumn *column;
column = gda_data_model_describe_column (cloud->priv->model, cloud->priv->label_column);
if (!column || (gda_column_get_g_type (column) != G_TYPE_STRING)) {
g_warning (_("Wrong column type for label: expecting a string and got a %s"),
gda_g_type_to_string (gda_column_get_g_type (column)));
return;
}
gint nrows, i;
nrows = gda_data_model_get_n_rows (cloud->priv->model);
/* compute scale range */
gdouble min_weight = G_MAXDOUBLE, max_weight = G_MINDOUBLE, wrange;
if ((cloud->priv->weight_column >= 0) || cloud->priv->weight_func) {
for (i = 0; i < nrows; i++) {
const GValue *cvalue;
gdouble weight = 1.;
if (cloud->priv->weight_func) {
weight = cloud->priv->weight_func (cloud->priv->model, i,
cloud->priv->weight_func_data);
min_weight = MIN (min_weight, weight);
max_weight = MAX (max_weight, weight);
}
else {
cvalue = gda_data_model_get_value_at (cloud->priv->model,
cloud->priv->weight_column, i, NULL);
if (cvalue) {
weight = g_ascii_strtod (gda_value_stringify (cvalue), NULL);
min_weight = MIN (min_weight, weight);
max_weight = MAX (max_weight, weight);
}
}
}
}
if (max_weight > min_weight)
wrange = (cloud->priv->max_scale - cloud->priv->min_scale) / (max_weight - min_weight);
else
wrange = 0.;
gtk_text_buffer_get_start_iter (tbuffer, &start);
for (i = 0; i < nrows; i++) {
const GValue *cvalue;
gdouble weight = 1.;
const gchar *ptr;
GString *string;
cvalue = gda_data_model_get_value_at (cloud->priv->model, cloud->priv->label_column, i, NULL);
if (!cvalue) {
TO_IMPLEMENT;
continue;
}
if (!g_value_get_string (cvalue))
continue;
/* convert spaces to non breaking spaces (0xC2 0xA0 as UTF8) */
string = g_string_new ("");
for (ptr = g_value_get_string (cvalue); *ptr; ptr++) {
if (*ptr == ' ') {
g_string_append_c (string, 0xC2);
g_string_append_c (string, 0xA0);
}
else
g_string_append_c (string, *ptr);
}
if ((cloud->priv->weight_column >= 0) || cloud->priv->weight_func) {
if (cloud->priv->weight_func) {
weight = cloud->priv->weight_func (cloud->priv->model, i,
cloud->priv->weight_func_data);
weight = cloud->priv->min_scale + wrange * (weight - min_weight);
}
else {
cvalue = gda_data_model_get_value_at (cloud->priv->model,
cloud->priv->weight_column, i, NULL);
if (cvalue) {
weight = g_ascii_strtod (gda_value_stringify (cvalue), NULL);
weight = cloud->priv->min_scale + wrange * (weight - min_weight);
}
}
}
GtkTextTag *tag;
tag = gtk_text_buffer_create_tag (cloud->priv->tbuffer, NULL,
"foreground", "#6161F2",
"scale", weight,
NULL);
g_object_set_data ((GObject*) tag, "row", GINT_TO_POINTER (i) + 1);
gtk_text_buffer_insert_with_tags (cloud->priv->tbuffer, &start, string->str, -1,
tag, NULL);
g_string_free (string, TRUE);
gtk_text_buffer_insert (cloud->priv->tbuffer, &start, " ", -1);
}
}
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;
}
static void
entry_info_fetched_done (EntryProperties *eprop, GdaLdapEntry *entry)
{
GtkTextBuffer *tbuffer;
GtkTextIter start, end;
TConnection *tcnc = eprop->priv->tcnc;
tbuffer = eprop->priv->text;
gtk_text_buffer_get_start_iter (tbuffer, &start);
gtk_text_buffer_get_end_iter (tbuffer, &end);
gtk_text_buffer_delete (tbuffer, &start, &end);
guint i;
GtkTextIter current;
gtk_text_buffer_get_start_iter (tbuffer, ¤t);
/* DN */
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t, _("Distinguished Name:"), -1,
"section", NULL);
gtk_text_buffer_insert (tbuffer, ¤t, "\n", -1);
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t, " ", -1, "starter", NULL);
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t, entry->dn, -1,
"data", NULL);
gtk_text_buffer_insert (tbuffer, ¤t, "\n", -1);
/* other attributes */
const gchar *basedn;
GdaDataHandler *ts_dh = NULL;
basedn = t_connection_ldap_get_base_dn (tcnc);
for (i = 0; i < entry->nb_attributes; i++) {
GdaLdapAttribute *attr;
gchar *tmp;
attr = entry->attributes [i];
tmp = g_strdup_printf ("%s:", attr->attr_name);
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t, tmp, -1, "section", NULL);
g_free (tmp);
gtk_text_buffer_insert (tbuffer, ¤t, "\n", -1);
guint j;
for (j = 0; j < attr->nb_values; j++) {
const GValue *cvalue;
cvalue = attr->values [j];
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t, " ", -1,
"starter", NULL);
if (G_VALUE_TYPE (cvalue) == GDA_TYPE_BINARY) {
GValue *copyvalue;
GtkTextTagTable *table;
GtkTextTag *tag;
GtkTextMark *mark;
copyvalue = gda_value_copy (cvalue);
table = gtk_text_buffer_get_tag_table (tbuffer);
tag = gtk_text_tag_new (NULL);
gtk_text_tag_table_add (table, tag);
g_object_set_data_full ((GObject*) tag, "binvalue",
copyvalue, (GDestroyNotify) gda_value_free);
g_object_unref ((GObject*) tag);
mark = gtk_text_buffer_create_mark (tbuffer, NULL, ¤t, TRUE);
GdkPixbuf *pixbuf;
pixbuf = data_to_pixbuf (cvalue);
if (pixbuf) {
gtk_text_buffer_insert_pixbuf (tbuffer, ¤t, pixbuf);
g_object_unref (pixbuf);
}
else {
GdaDataHandler *dh;
dh = gda_data_handler_get_default (G_VALUE_TYPE (cvalue));
if (dh)
tmp = gda_data_handler_get_str_from_value (dh, cvalue);
else
tmp = gda_value_stringify (cvalue);
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t,
tmp, -1,
"data", NULL);
g_free (tmp);
}
GtkTextIter before;
gtk_text_buffer_get_iter_at_mark (tbuffer, &before, mark);
gtk_text_buffer_apply_tag (tbuffer, tag, &before, ¤t);
gtk_text_buffer_delete_mark (tbuffer, mark);
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t,
"\n", 1,
"data", NULL);
}
else {
GdaDataHandler *dh;
dh = gda_data_handler_get_default (G_VALUE_TYPE (cvalue));
if (dh)
tmp = gda_data_handler_get_str_from_value (dh, cvalue);
else
tmp = gda_value_stringify (cvalue);
if (tmp) {
if (*tmp &&
((basedn && g_str_has_suffix (tmp, basedn)) || !basedn) &&
gda_ldap_is_dn (tmp)) {
/* we have a DN */
GtkTextTag *tag;
tag = gtk_text_buffer_create_tag (tbuffer, NULL,
"foreground", "blue",
"weight", PANGO_WEIGHT_NORMAL,
"underline", PANGO_UNDERLINE_SINGLE,
NULL);
g_object_set_data_full (G_OBJECT (tag), "dn",
g_strdup (tmp), g_free);
gtk_text_buffer_insert_with_tags (tbuffer, ¤t,
tmp, -1,
tag, NULL);
}
else if (attr->attr_name &&
!g_ascii_strcasecmp (attr->attr_name, "objectClass")) {
GtkTextTag *tag;
tag = gtk_text_buffer_create_tag (tbuffer, NULL,
"foreground", "blue",
"weight", PANGO_WEIGHT_NORMAL,
"underline", PANGO_UNDERLINE_SINGLE,
NULL);
g_object_set_data_full (G_OBJECT (tag), "class",
g_strdup (tmp), g_free);
gtk_text_buffer_insert_with_tags (tbuffer, ¤t,
tmp, -1,
tag, NULL);
}
else
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t, tmp, -1,
"data", NULL);
gchar *extrainfo = NULL;
if (!strncmp (attr->attr_name, "shadow", 6) &&
(!strcmp (attr->attr_name, "shadowLastChange") ||
!strcmp (attr->attr_name, "shadowMax") ||
!strcmp (attr->attr_name, "shadowMin") ||
!strcmp (attr->attr_name, "shadowInactive") ||
!strcmp (attr->attr_name, "shadowExpire")))
extrainfo = unix_shadow_to_string (tmp, attr->attr_name);
else if (!strcmp (attr->attr_name, "badPasswordTime") ||
!strcmp (attr->attr_name, "lastLogon") ||
!strcmp (attr->attr_name, "pwdLastSet") ||
!strcmp (attr->attr_name, "accountExpires") ||
!strcmp (attr->attr_name, "lockoutTime") ||
!strcmp (attr->attr_name, "lastLogonTimestamp"))
extrainfo = ad_1601_timestamp_to_string (tmp, attr->attr_name);
else if (!strcmp (attr->attr_name, "userAccountControl"))
extrainfo = ad_1601_uac_to_string (tmp);
else if (!strcmp (attr->attr_name, "sAMAccountType"))
extrainfo = ad_sam_account_type_to_string (tmp);
if (extrainfo) {
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t,
" ", 1,
"data", NULL);
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t,
extrainfo, -1,
"convdata", NULL);
g_free (extrainfo);
}
g_free (tmp);
}
else {
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t, _("Can't display attribute value"), -1,
"error", NULL);
}
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t,
"\n", 1,
"data", NULL);
}
}
}
if (ts_dh)
g_object_unref (ts_dh);
gda_ldap_entry_free (entry);
if (eprop->priv->text_search && gtk_widget_get_visible (eprop->priv->text_search))
text_search_rerun (TEXT_SEARCH (eprop->priv->text_search));
}
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
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);
}
/**
* base_tool_output_data_model_to_string:
*/
gchar *
base_tool_output_data_model_to_string (GdaDataModel *model, ToolOutputFormat format, FILE *stream, GdaSet *options)
{
if (!GDA_IS_DATA_MODEL (model))
return NULL;
if (format & BASE_TOOL_OUTPUT_FORMAT_DEFAULT) {
gchar *tmp;
GdaSet *local_options;
gint width;
base_tool_input_get_size (&width, NULL);
local_options = gda_set_new_inline (6, "NAME", G_TYPE_BOOLEAN, TRUE,
"NULL_AS_EMPTY", G_TYPE_BOOLEAN, TRUE,
"MAX_WIDTH", G_TYPE_INT, width,
"COLUMN_SEPARATORS", G_TYPE_BOOLEAN, TRUE,
"SEPARATOR_LINE", G_TYPE_BOOLEAN, TRUE,
"NAMES_ON_FIRST_LINE", G_TYPE_BOOLEAN, TRUE);
if (options)
gda_set_merge_with_set (local_options, options);
tmp = gda_data_model_export_to_string (model, GDA_DATA_MODEL_IO_TEXT_TABLE, NULL, 0, NULL, 0,
local_options);
g_object_unref (local_options);
if (GDA_IS_DATA_SELECT (model)) {
gchar *tmp2, *tmp3;
gdouble etime;
g_object_get ((GObject*) model, "execution-delay", &etime, NULL);
tmp2 = g_strdup_printf ("%s: %.03f s", _("Execution delay"), etime);
tmp3 = g_strdup_printf ("%s\n%s", tmp, tmp2);
g_free (tmp);
g_free (tmp2);
return tmp3;
}
else
return tmp;
}
else if (format & BASE_TOOL_OUTPUT_FORMAT_XML)
return gda_data_model_export_to_string (model, GDA_DATA_MODEL_IO_DATA_ARRAY_XML,
NULL, 0,
NULL, 0, NULL);
else if (format & BASE_TOOL_OUTPUT_FORMAT_CSV) {
gchar *retval;
GdaSet *optexp;
optexp = make_options_set_from_string ("csv", options);
retval = gda_data_model_export_to_string (model, GDA_DATA_MODEL_IO_TEXT_SEPARATED,
NULL, 0,
NULL, 0, optexp);
if (optexp)
g_object_unref (optexp);
return retval;
}
else if (format & BASE_TOOL_OUTPUT_FORMAT_HTML) {
xmlBufferPtr buffer;
xmlNodePtr top, div, table, node, row_node, col_node, header, meta;
gint ncols, nrows, i, j;
gchar *str;
top = xmlNewNode (NULL, BAD_CAST "html");
header = xmlNewChild (top, NULL, BAD_CAST "head", NULL);
meta = xmlNewChild (header, NULL, BAD_CAST "meta", NULL);
xmlSetProp (meta, BAD_CAST "http-equiv", BAD_CAST "content-type");
xmlSetProp (meta, BAD_CAST "content", BAD_CAST "text/html; charset=UTF-8");
div = xmlNewChild (top, NULL, BAD_CAST "body", NULL);
table = xmlNewChild (div, NULL, BAD_CAST "table", NULL);
xmlSetProp (table, BAD_CAST "border", BAD_CAST "1");
if (g_object_get_data (G_OBJECT (model), "name"))
xmlNewTextChild (table, NULL, BAD_CAST "caption", g_object_get_data (G_OBJECT (model), "name"));
ncols = gda_data_model_get_n_columns (model);
nrows = gda_data_model_get_n_rows (model);
row_node = xmlNewChild (table, NULL, BAD_CAST "tr", NULL);
for (j = 0; j < ncols; j++) {
const gchar *cstr;
cstr = gda_data_model_get_column_title (model, j);
col_node = xmlNewTextChild (row_node, NULL, BAD_CAST "th", BAD_CAST cstr);
xmlSetProp (col_node, BAD_CAST "align", BAD_CAST "center");
}
for (i = 0; i < nrows; i++) {
row_node = xmlNewChild (table, NULL, BAD_CAST "tr", NULL);
xmlSetProp (row_node, BAD_CAST "valign", BAD_CAST "top");
for (j = 0; j < ncols; j++) {
const GValue *value;
value = gda_data_model_get_value_at (model, j, i, NULL);
if (!value) {
col_node = xmlNewChild (row_node, NULL, BAD_CAST "td", BAD_CAST "ERROR");
xmlSetProp (col_node, BAD_CAST "align", BAD_CAST "left");
}
else {
str = gda_value_stringify (value);
col_node = xmlNewTextChild (row_node, NULL, BAD_CAST "td", BAD_CAST str);
xmlSetProp (col_node, BAD_CAST "align", BAD_CAST "left");
g_free (str);
}
}
}
node = xmlNewChild (div, NULL, BAD_CAST "p", NULL);
str = g_strdup_printf (ngettext ("(%d row)", "(%d rows)", nrows), nrows);
xmlNodeSetContent (node, BAD_CAST str);
g_free (str);
buffer = xmlBufferCreate ();
xmlNodeDump (buffer, NULL, top, 0, 1);
str = g_strdup ((gchar *) xmlBufferContent (buffer));
xmlBufferFree (buffer);
xmlFreeNode (top);
return str;
}
else
TO_IMPLEMENT;
return NULL;
}
/**
* 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;
}
}
/*
* REM: if @attr_names is not NULL, then @cols_size will have the same number of items
*
* - Optionally called once with @out_max_prefix_size not %NULL and @in_string %NULL => compute
* cols_size[x] and *out_max_prefix_size
* - Called once with @in_string not %NULL and @out_max_prefix_size %NULL
*/
static void
tree_node_to_string (GdaTreeNode *node, gboolean has_parent, gboolean has_next_sibling,
const gchar *prefix,
gchar **attr_names, guint *cols_size, guint max_prefix_size,
guint *out_max_prefix_size, GString *in_string)
{
gchar *pipe = "|";
gchar *prefix2 = "|- ";
gchar *prefix3 = "`- ";
pipe = "│";
prefix2 = "├─ ";
prefix3 = "└─ ";
#define SEP " "
const GValue *cvalue;
gchar *p;
const gchar *cstr;
guint i;
/* prefix */
if (has_next_sibling)
p = g_strdup_printf ("%s%s", prefix, prefix2);
else
p = g_strdup_printf ("%s%s", prefix, prefix3);
if (in_string)
g_string_append (in_string, p);
i = g_utf8_strlen (p, -1);
g_free (p);
/* node name */
cvalue = gda_tree_node_get_node_attribute (node, GDA_ATTRIBUTE_NAME);
cstr = cvalue && g_value_get_string (cvalue)? g_value_get_string (cvalue) : "???";
if (in_string)
g_string_append (in_string, cstr);
/* padding */
if (in_string) {
for (i = i + g_utf8_strlen (cstr, -1); i < max_prefix_size; i++)
g_string_append_c (in_string, ' ');
}
else {
guint size = i;
if (g_utf8_validate (cstr, -1, NULL))
size += g_utf8_strlen (cstr, -1);
else
size += strlen (cstr);
*out_max_prefix_size = MAX (size, *out_max_prefix_size);
}
/* some node's attributes */
if (attr_names) {
for (i = 0; attr_names[i] && *attr_names[i]; i++) {
guint colsize = 0;
if (in_string) {
if (cols_size [i] == 0)
continue; /* ignore this attribute as it's not set */
g_string_append (in_string, SEP);
}
cvalue = gda_tree_node_get_node_attribute (node, attr_names[i]);
if (cvalue && (G_VALUE_TYPE (cvalue) != GDA_TYPE_NULL)) {
gchar *tmp = NULL;
if (G_VALUE_TYPE (cvalue) == G_TYPE_FLOAT)
tmp = g_strdup_printf ("%.01f", g_value_get_float (cvalue));
else {
GdaDataHandler *dh;
dh = gda_data_handler_get_default (G_VALUE_TYPE (cvalue));
if (dh)
tmp = gda_data_handler_get_str_from_value (dh, cvalue);
else
tmp = gda_value_stringify (cvalue);
}
if (in_string) {
gboolean right = FALSE;
if ((G_VALUE_TYPE (cvalue) == G_TYPE_INT) ||
(G_VALUE_TYPE (cvalue) == G_TYPE_UINT) ||
(G_VALUE_TYPE (cvalue) == G_TYPE_INT64) ||
(G_VALUE_TYPE (cvalue) == G_TYPE_UINT64) ||
(G_VALUE_TYPE (cvalue) == G_TYPE_FLOAT) ||
(G_VALUE_TYPE (cvalue) == G_TYPE_DOUBLE) ||
(G_VALUE_TYPE (cvalue) == G_TYPE_CHAR) ||
(G_VALUE_TYPE (cvalue) == GDA_TYPE_SHORT) ||
(G_VALUE_TYPE (cvalue) == GDA_TYPE_USHORT))
right = TRUE;
if (right) {
/* right align */
guint j;
for (j = tmp ? g_utf8_strlen (tmp, -1) : 0; j < cols_size [i]; j++)
g_string_append_c (in_string, ' ');
if (tmp) {
if (g_utf8_strlen (tmp, -1) > cols_size[i])
tmp [cols_size [i]] = 0;
g_string_append (in_string, tmp);
}
}
else {
/* left align */
if (tmp) {
if (g_utf8_strlen (tmp, -1) > cols_size[i])
tmp [cols_size [i]] = 0;
g_string_append (in_string, tmp);
}
guint j;
for (j = tmp ? g_utf8_strlen (tmp, -1) : 0; j < cols_size [i]; j++)
g_string_append_c (in_string, ' ');
}
}
else {
if (tmp) {
if (g_utf8_validate (tmp, -1, NULL))
colsize += g_utf8_strlen (tmp, -1);
else
colsize += strlen (tmp);
}
cols_size [i] = MAX (cols_size [i], colsize);
}
g_free (tmp);
}
else if (in_string) {
guint j;
for (j = 0; j < cols_size [i]; j++)
g_string_append_c (in_string, ' ');
}
}
}
if (in_string)
g_string_append_c (in_string, '\n');
/* children */
gchar *ch_prefix;
if (has_next_sibling)
ch_prefix = g_strdup_printf ("%s%s ", prefix, pipe);
else
ch_prefix = g_strdup_printf ("%s ", prefix);
GSList *top, *list;
top = gda_tree_node_get_children (node);
for (list = top; list; list = list->next)
tree_node_to_string (GDA_TREE_NODE (list->data), TRUE, list->next ? TRUE : FALSE,
ch_prefix, attr_names, cols_size, max_prefix_size,
out_max_prefix_size, in_string);
g_slist_free (top);
g_free (ch_prefix);
}
static void
assistant_applied_cb (GtkAssistant *assist, G_GNUC_UNUSED gpointer data)
{
gboolean allok = TRUE;
GString *cnc_string = NULL;
GdauiDsnAssistant *assistant = (GdauiDsnAssistant *) assist;
g_return_if_fail (GDAUI_IS_DSN_ASSISTANT (assistant));
/* clear the internal dsn_info */
if (assistant->priv->dsn_info) {
data_source_info_free (assistant->priv->dsn_info);
assistant->priv->dsn_info = NULL;
}
/* New database creation first */
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (assistant->priv->choose_toggle))) {
if (!gda_server_operation_is_valid (assistant->priv->create_db_op, NULL, NULL)) {
_gdaui_utility_show_error (NULL, _("Missing mandatory information, to create database"));
gtk_assistant_set_current_page (assist, PAGE_CREATE_DB_INFO);
return;
}
else {
GdaProviderInfo *prov_info;
GSList *dsn_params;
GError *error = NULL;
allok = gda_server_operation_perform_create_database (assistant->priv->create_db_op, NULL, &error);
if (!allok) {
gchar *str;
str = g_strdup_printf (_("Error creating database: %s"),
error && error->message ? error->message : _("Unknown error"));
_gdaui_utility_show_error (NULL, str);
g_free (str);
gtk_assistant_set_current_page (assist, PAGE_CREATE_DB_INFO);
return;
}
/* make the connection string for the data source */
prov_info = gda_config_get_provider_info (gdaui_provider_selector_get_provider
(GDAUI_PROVIDER_SELECTOR (assistant->priv->general_provider)));
g_return_if_fail (prov_info);
for (dsn_params = prov_info->dsn_params->holders; dsn_params; dsn_params = dsn_params->next) {
GdaHolder *param = GDA_HOLDER (dsn_params->data);
const GValue *value;
value = gda_server_operation_get_value_at (assistant->priv->create_db_op,
"/DB_DEF_P/%s",
gda_holder_get_id (param));
if (!value)
value = gda_server_operation_get_value_at (assistant->priv->create_db_op,
"/SERVER_CNX_P/%s",
gda_holder_get_id (param));
if (value && !gda_value_is_null ((GValue *) value)) {
gchar *str;
if (dsn_params == prov_info->dsn_params->holders)
cnc_string = g_string_new ("");
else
g_string_append (cnc_string, ";");
str = gda_value_stringify ((GValue *) value);
g_string_append_printf (cnc_string, "%s=%s", gda_holder_get_id (param), str);
g_free (str);
}
}
}
}
/* Data source declaration */
if (allok) {
assistant->priv->dsn_info = g_new0 (GdaDsnInfo, 1);
assistant->priv->dsn_info->name = g_strdup (gtk_entry_get_text (GTK_ENTRY (assistant->priv->general_name)));
assistant->priv->dsn_info->provider = g_strdup (
gdaui_provider_selector_get_provider (
GDAUI_PROVIDER_SELECTOR (assistant->priv->general_provider)));
if (cnc_string) {
assistant->priv->dsn_info->cnc_string = cnc_string->str;
g_string_free (cnc_string, FALSE);
}
else
assistant->priv->dsn_info->cnc_string = _gdaui_provider_spec_editor_get_specs
(GDAUI_PROVIDER_SPEC_EDITOR (assistant->priv->provider_detail));
assistant->priv->dsn_info->description =
g_strdup (gtk_entry_get_text (GTK_ENTRY (assistant->priv->general_description)));
assistant->priv->dsn_info->auth_string = NULL;
if (assistant->priv->auth_detail)
assistant->priv->dsn_info->auth_string =
_gdaui_provider_auth_editor_get_auth (GDAUI_PROVIDER_AUTH_EDITOR (assistant->priv->auth_detail));
if (gda_config_can_modify_system_config ())
assistant->priv->dsn_info->is_system = gtk_toggle_button_get_active
(GTK_TOGGLE_BUTTON (assistant->priv->general_is_system));
else
assistant->priv->dsn_info->is_system = FALSE;
}
/* notify listeners */
g_signal_emit (G_OBJECT (assistant), config_assistant_signals[FINISHED], 0, !allok);
}
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);
}
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;
}
/*
* 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 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;
}
}
