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; } }