static void
fetch_execute_result (GdaConnection *cnc, guint task_id)
{
GObject *result;
GError *error = NULL;
gint i;
for (i = 0; i < 10; i++) {
g_print ("=========== Waiting for task %u\n", task_id);
result = gda_connection_async_fetch_result (cnc, task_id, NULL, &error);
if (result) {
if (GDA_IS_DATA_MODEL (result))
gda_data_model_dump (GDA_DATA_MODEL (result), NULL);
else
g_print ("Unknown result: %s\n", G_OBJECT_TYPE_NAME (result));
g_object_unref (result);
return;
}
else if (error) {
if (error && (error->domain == GDA_CONNECTION_ERROR) &&
(error->code == GDA_CONNECTION_TASK_NOT_FOUND_ERROR))
g_print ("Task not found error: %s\n", error->message);
else
g_print ("Execution failed: %s\n", error->message ? error->message : "No detail");
return;
}
else {
g_print ("Not yet executed...\n");
g_usleep (100000);
}
}
}
static void
gda_data_meta_wrapper_set_property (GObject *object,
guint param_id,
const GValue *value,
GParamSpec *pspec)
{
GdaDataMetaWrapper *model;
model = GDA_DATA_META_WRAPPER (object);
if (model->priv) {
switch (param_id) {
case PROP_MODEL: {
GdaDataModel *mod = g_value_get_object(value);
if (mod) {
g_return_if_fail (GDA_IS_DATA_MODEL (mod));
if (! (gda_data_model_get_access_flags (mod) & GDA_DATA_MODEL_ACCESS_RANDOM)) {
g_warning ("Internal implementation error: data model does not support random access");
return;
}
if (model->priv->model)
g_object_unref (model->priv->model);
model->priv->model = mod;
g_object_ref (mod);
model->priv->nb_cols = gda_data_model_get_n_columns (mod);
}
break;
}
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
break;
}
}
}
static gboolean
exec_statement (GdaConnection *cnc, GdaStatement *stmt, GdaSet *plist, GError **error)
{
GObject *exec_res;
exec_res = gda_connection_statement_execute (cnc, stmt, plist, GDA_STATEMENT_MODEL_RANDOM_ACCESS, NULL, error);
if (!exec_res)
return FALSE;
if (GDA_IS_DATA_MODEL (exec_res)) {
g_print ("Query returned a GdaDataModel...\n");
gda_data_model_dump ((GdaDataModel*) exec_res, stdout);
}
else {
if (GDA_IS_SET (exec_res)) {
GSList *list;
g_print ("Query returned a GdaSet:\n");
for (list = GDA_SET (exec_res)->holders; list; list = list->next) {
gchar *str;
str = gda_holder_get_value_str (GDA_HOLDER (list->data), NULL);
g_print (" %s => %s\n", gda_holder_get_id (GDA_HOLDER (list->data)), str);
g_free (str);
}
}
else
g_print ("Query returned a %s object\n", G_OBJECT_TYPE_NAME (exec_res));
}
return TRUE;
}
/**
* gda_data_meta_wrapper_new:
* @model: a #GdaDataModel
*
* Creates a new #GdaDataModel object which buffers the rows of @model. This object is useful
* only if @model can only be metaed using cursor based method.
*
* Returns: a pointer to the newly created #GdaDataModel.
*/
GdaDataModel *
_gda_data_meta_wrapper_new (GdaDataModel *model, gboolean reusable, gint *cols,
gint size, GdaSqlIdentifierStyle mode,
GdaSqlReservedKeywordsFunc reserved_keyword_func)
{
GdaDataMetaWrapper *retmodel;
g_return_val_if_fail (GDA_IS_DATA_MODEL (model), NULL);
retmodel = g_object_new (GDA_TYPE_DATA_META_WRAPPER,
"model", model, NULL);
retmodel->priv->cols_to_wrap = g_new (gint, size);
memcpy (retmodel->priv->cols_to_wrap, cols, sizeof (gint) * size); /* Flawfinder: ignore */
retmodel->priv->cols_to_wrap_size = size;
retmodel->priv->mode = mode;
retmodel->priv->reserved_keyword_func = reserved_keyword_func;
if (reusable)
retmodel->priv->computed_rows = g_hash_table_new_full (g_int_hash, g_int_equal,
NULL, (GDestroyNotify) comp_row_free);
else {
retmodel->priv->buffer = g_new0 (CompRow, 1);
retmodel->priv->buffer->size = size;
retmodel->priv->buffer->values = g_new0 (GValue *, size);
}
return GDA_DATA_MODEL (retmodel);
}
/**
* ui_formgrid_new
* @model: a #GdaDataModel
* @scroll_form: set to %TRUE to wrap the embedded form in a scrolled window
* @flags: the #GdauiDataProxyInfoFlag, specifying what to display in the new widget
*
* Creates a new #UiFormGrid widget suitable to display the data in @model
*
* Returns: the new widget
*/
GtkWidget *
ui_formgrid_new (GdaDataModel *model, gboolean scroll_form, GdauiDataProxyInfoFlag flags)
{
UiFormGrid *formgrid;
GdaDataProxy *proxy;
g_return_val_if_fail (!model || GDA_IS_DATA_MODEL (model), NULL);
formgrid = (UiFormGrid *) g_object_new (UI_TYPE_FORMGRID, "scroll-form", scroll_form, NULL);
formgrid->priv->flags = flags;
/* a raw form and a raw grid for the same proxy */
g_object_set (formgrid->priv->raw_grid, "model", model, NULL);
proxy = gdaui_data_proxy_get_proxy (GDAUI_DATA_PROXY (formgrid->priv->raw_grid));
g_object_set (formgrid->priv->raw_form, "model", proxy, NULL);
gdaui_data_proxy_set_write_mode (GDAUI_DATA_PROXY (formgrid->priv->raw_form),
GDAUI_DATA_PROXY_WRITE_ON_DEMAND);
g_object_set (G_OBJECT (formgrid->priv->info),
"flags", formgrid->priv->flags | GRID_FLAGS, NULL);
g_signal_connect (formgrid->priv->raw_grid, "proxy-changed",
G_CALLBACK (proxy_changed_cb), formgrid);
/* no more than 300 rows at a time */
if (model) {
gda_data_proxy_set_sample_size (proxy, 300);
if (flags & GDAUI_DATA_PROXY_INFO_ROW_MODIFY_BUTTONS)
g_object_set (G_OBJECT (formgrid), "compute-mod-statements", TRUE, NULL);
}
return (GtkWidget *) formgrid;
}
static void
gda_data_access_wrapper_set_property (GObject *object,
guint param_id,
const GValue *value,
GParamSpec *pspec)
{
GdaDataAccessWrapper *model;
model = GDA_DATA_ACCESS_WRAPPER (object);
if (model->priv) {
switch (param_id) {
case PROP_MODEL: {
GdaDataModel *mod = g_value_get_object (value);
if (mod) {
g_return_if_fail (GDA_IS_DATA_MODEL (mod));
model->priv->model_access_flags = gda_data_model_get_access_flags (mod);
if (model->priv->model_access_flags & GDA_DATA_MODEL_ACCESS_RANDOM) {
g_signal_connect (G_OBJECT (mod), "row-inserted",
G_CALLBACK (model_row_inserted_cb), model);
g_signal_connect (G_OBJECT (mod), "row-updated",
G_CALLBACK (model_row_updated_cb), model);
g_signal_connect (G_OBJECT (mod), "row-removed",
G_CALLBACK (model_row_removed_cb), model);
g_signal_connect (G_OBJECT (mod), "reset",
G_CALLBACK (model_reset_cb), model);
}
else {
model->priv->iter = gda_data_model_create_iter (mod);
g_return_if_fail (model->priv->iter);
g_object_set (model->priv->iter, "validate-changes", FALSE,
NULL);
g_signal_connect (G_OBJECT (model->priv->iter), "row-changed",
G_CALLBACK (iter_row_changed_cb), model);
g_signal_connect (G_OBJECT (model->priv->iter), "end-of-data",
G_CALLBACK (iter_end_of_data_cb), model);
model->priv->iter_row = -1; /* because model->priv->iter is invalid */
model->priv->rows = g_hash_table_new_full (g_int_hash, g_int_equal,
g_free,
(GDestroyNotify) g_object_unref);
}
if (model->priv->model)
g_object_unref (model->priv->model);
model->priv->model = mod;
g_object_ref (mod);
compute_columns (model);
}
break;
}
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
break;
}
}
}
/**
* gdaui_data_selector_set_model:
* @iface: an object which implements the #GdauiDataSelector interface
* @model: a #GdaDataModel to use
*
* Sets the data model from which the data being displayed are. Also see gdaui_data_selector_get_model()
*
* Since: 4.2
*/
void
gdaui_data_selector_set_model (GdauiDataSelector *iface, GdaDataModel *model)
{
g_return_if_fail (GDAUI_IS_DATA_SELECTOR (iface));
g_return_if_fail (!model || GDA_IS_DATA_MODEL (model));
if (GDAUI_DATA_SELECTOR_GET_IFACE (iface)->set_model)
(GDAUI_DATA_SELECTOR_GET_IFACE (iface)->set_model) (iface, model);
}
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);
}
}
/**
* gda_data_access_wrapper_new:
* @model: a #GdaDataModel
*
* Creates a new #GdaDataModel object which buffers the rows of @model. This object is useful
* only if @model can only be accessed using cursor based method.
*
* Returns: (transfer full): a pointer to the newly created #GdaDataModel.
*/
GdaDataModel *
gda_data_access_wrapper_new (GdaDataModel *model)
{
GdaDataAccessWrapper *retmodel;
g_return_val_if_fail (GDA_IS_DATA_MODEL (model), NULL);
retmodel = g_object_new (GDA_TYPE_DATA_ACCESS_WRAPPER,
"model", model, NULL);
return GDA_DATA_MODEL (retmodel);
}
/**
* gdaui_cloud_new:
* @model: a #GdaDataModel
*
* Creates a new #GdauiCloud widget suitable to display the data in @model
*
* Returns: (transfer full): the new widget
*
* Since: 4.2
*/
GtkWidget *
gdaui_cloud_new (GdaDataModel *model, gint label_column, gint weight_column)
{
GdauiCloud *cloud;
g_return_val_if_fail (!model || GDA_IS_DATA_MODEL (model), NULL);
if (label_column < -1)
label_column = -1;
if (weight_column < -1)
weight_column = -1;
cloud = (GdauiCloud *) g_object_new (GDAUI_TYPE_CLOUD,
"label-column", label_column,
"weight-column", weight_column,
"model", model, NULL);
return (GtkWidget *) cloud;
}
gboolean
_midgard_dbobject_get_property (MidgardDBObject *self, const gchar *name, GValue *value)
{
g_return_val_if_fail (self != NULL, FALSE);
g_return_val_if_fail (name != NULL, FALSE);
g_return_val_if_fail (G_IS_VALUE (value), FALSE);
if (!self->dbpriv->datamodel)
return FALSE;
GdaDataModel *model = GDA_DATA_MODEL (self->dbpriv->datamodel);
if (!model || (model && !GDA_IS_DATA_MODEL (model)))
return FALSE;
gint col_idx = gda_data_model_get_column_index (model, name);
if (col_idx == -1)
return FALSE;
const GValue *src_val = gda_data_model_get_value_at (model, col_idx, self->dbpriv->row, NULL);
if (!src_val)
return FALSE;
if (!G_IS_VALUE (src_val)
|| (G_IS_VALUE (src_val)
&& G_VALUE_TYPE (src_val) == GDA_TYPE_NULL)) {
/* NULL fetched from underlying field */
if (G_VALUE_HOLDS_STRING (value)) {
g_value_set_string (value, "");
return TRUE;
}
g_warning ("Can not find value for given '%s' property \n", name);
return FALSE;
}
if (G_VALUE_TYPE (src_val) != G_VALUE_TYPE (value))
g_value_transform (src_val, value);
else
g_value_copy (src_val, value);
if (G_VALUE_HOLDS_STRING (value) && g_value_get_string (value) == NULL)
g_value_set_string (value, "");
return TRUE;
}
/**
* gda_data_model_array_copy_model:
* @src: a #GdaDataModel to copy data from
* @error: a place to store errors, or %NULL
*
* Makes a copy of @src into a new #GdaDataModelArray object
*
* Returns: (transfer full) (allow-none): a new data model, or %NULL if an error occurred
*/
GdaDataModelArray *
gda_data_model_array_copy_model (GdaDataModel *src, GError **error)
{
GdaDataModel *model;
gint nbfields, i;
g_return_val_if_fail (GDA_IS_DATA_MODEL (src), NULL);
nbfields = gda_data_model_get_n_columns (src);
model = gda_data_model_array_new (nbfields);
if (g_object_get_data (G_OBJECT (src), "name"))
g_object_set_data_full (G_OBJECT (model), "name", g_strdup (g_object_get_data (G_OBJECT (src), "name")), g_free);
if (g_object_get_data (G_OBJECT (src), "descr"))
g_object_set_data_full (G_OBJECT (model), "descr", g_strdup (g_object_get_data (G_OBJECT (src), "descr")), g_free);
for (i = 0; i < nbfields; i++) {
GdaColumn *copycol, *srccol;
gchar *colid;
srccol = gda_data_model_describe_column (src, i);
copycol = gda_data_model_describe_column (model, i);
g_object_get (G_OBJECT (srccol), "id", &colid, NULL);
g_object_set (G_OBJECT (copycol), "id", colid, NULL);
g_free (colid);
gda_column_set_description (copycol, gda_column_get_description (srccol));
gda_column_set_name (copycol, gda_column_get_name (srccol));
gda_column_set_dbms_type (copycol, gda_column_get_dbms_type (srccol));
gda_column_set_g_type (copycol, gda_column_get_g_type (srccol));
gda_column_set_position (copycol, gda_column_get_position (srccol));
gda_column_set_allow_null (copycol, gda_column_get_allow_null (srccol));
}
if (! gda_data_model_import_from_model (model, src, FALSE, NULL, error)) {
g_object_unref (model);
model = NULL;
}
/*else
gda_data_model_dump (model, stdout);*/
return (GdaDataModelArray*) model;
}
GPtrArray *
symbol_db_util_get_files_with_zero_symbols (SymbolDBEngine *dbe)
{
SymbolDBEnginePriv *priv;
GdaDataModel *data_model;
GPtrArray *files_to_scan;
const GdaStatement *stmt;
gint i, num_rows = 0;
g_return_val_if_fail (dbe != NULL, NULL);
priv = dbe->priv;
SDB_LOCK(priv);
if ((stmt = sdb_engine_get_statement_by_query_id (dbe,
PREP_QUERY_GET_ALL_FROM_FILE_WHERE_NOT_IN_SYMBOLS))
== NULL)
{
SDB_UNLOCK(priv);
return NULL;
}
data_model = gda_connection_statement_execute_select (priv->db_connection,
(GdaStatement*)stmt,
NULL, NULL);
if (!GDA_IS_DATA_MODEL (data_model) ||
(num_rows = gda_data_model_get_n_rows (GDA_DATA_MODEL (data_model))) <= 0)
{
if (data_model != NULL)
g_object_unref (data_model);
SDB_UNLOCK(priv);
return NULL;
}
/* initialize the array */
files_to_scan = g_ptr_array_new_with_free_func (g_free);
/* we can now scan each filename entry to check the last modification time. */
for (i = 0; i < num_rows; i++)
{
const GValue *value;
const gchar *file_name;
gchar *file_abs_path = NULL;
if ((value =
gda_data_model_get_value_at (data_model,
gda_data_model_get_column_index(data_model, "db_file_path"),
i, NULL)) == NULL)
{
continue;
}
/* build abs path. */
file_name = g_value_get_string (value);
file_abs_path = symbol_db_util_get_full_local_path (dbe, file_name);
g_ptr_array_add (files_to_scan, file_abs_path);
}
g_object_unref (data_model);
SDB_UNLOCK(priv);
return files_to_scan;
}
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);
}
}
SimEvent *
sim_event_light_new_from_dm (GdaDataModel *dm, gint row)
{
SimEvent *event;
const GValue *value;
const GdaBinary *binary;
const GdaTimestamp *timestamp;
struct tm tm;
g_return_val_if_fail (GDA_IS_DATA_MODEL (dm), NULL);
event = sim_event_new ();
event->id = sim_uuid_new ();
value = gda_data_model_get_value_at (dm, 0, row, NULL);
if (!gda_value_is_null (value))
{
binary = (GdaBinary *) gda_value_get_blob (value);
event->src_ia = sim_inet_new_from_db_binary (binary->data, binary->binary_length);
}
value = gda_data_model_get_value_at (dm, 1, row, NULL);
if (!gda_value_is_null (value))
{
binary = (GdaBinary *) gda_value_get_blob (value);
event->dst_ia = sim_inet_new_from_db_binary (binary->data, binary->binary_length);
}
value = gda_data_model_get_value_at (dm, 2, row, NULL);
if (!gda_value_is_null (value))
event->src_id = sim_uuid_new_from_blob (gda_value_get_blob (value));
value = gda_data_model_get_value_at (dm, 3, row, NULL);
if (!gda_value_is_null (value))
event->dst_id = sim_uuid_new_from_blob (gda_value_get_blob (value));
value = gda_data_model_get_value_at (dm, 4, row, NULL);
event->src_port = gda_value_is_null (value) ? 0 : g_value_get_int (value);
value = gda_data_model_get_value_at (dm, 5, row, NULL);
event->dst_port = gda_value_is_null (value) ? 0 : g_value_get_int (value);
value = gda_data_model_get_value_at (dm, 6, row, NULL);
if (!gda_value_is_null (value))
{
timestamp = gda_value_get_timestamp (value);
tm.tm_year = timestamp->year - 1900;
tm.tm_mon = timestamp->month - 1;
tm.tm_mday = timestamp->day;
tm.tm_hour = timestamp->hour - 1;
tm.tm_min = timestamp->minute;
tm.tm_mday = timestamp->day;
tm.tm_sec = timestamp->second;
tm.tm_wday = 0;
tm.tm_yday = 0;
tm.tm_isdst = 0;
event->time = mktime (&tm);
}
value = gda_data_model_get_value_at (dm, 7, row, NULL);
event->tzone = gda_value_is_null (value) ? 0.0 : g_value_get_float (value);
return event;
}
static void
execute_action_mitem_cb (GtkMenuItem *menuitem, UiFormGrid *formgrid)
{
TFavoritesAction *act;
GtkWidget *dlg;
gchar *tmp;
gint response;
GtkWidget *toplevel;
act = (TFavoritesAction*) g_object_get_data (G_OBJECT (menuitem), "action");
toplevel = gtk_widget_get_toplevel ((GtkWidget*) formgrid);
tmp = g_strdup_printf (_("Set or confirm the parameters to execute\n"
"action '%s'"), act->name);
dlg = gdaui_basic_form_new_in_dialog (act->params,
(GtkWindow*) toplevel,
_("Execution of action"), tmp);
g_free (tmp);
response = gtk_dialog_run (GTK_DIALOG (dlg));
gtk_widget_destroy (dlg);
if (response == GTK_RESPONSE_ACCEPT) {
GError *lerror = NULL;
TConnection *tcnc;
tcnc = get_t_connection (formgrid);
g_assert (tcnc);
GObject *result;
result = t_connection_execute_statement (tcnc, act->stmt, act->params,
GDA_STATEMENT_MODEL_RANDOM_ACCESS, NULL,
&lerror);
if (result && GDA_IS_DATA_MODEL (result)) {
GtkWidget *dialog, *label, *fg;
GtkWidget *dcontents;
gchar *tmp;
dialog = gtk_dialog_new_with_buttons (act->name, NULL, 0,
_("_Close"), GTK_RESPONSE_CLOSE, NULL);
dcontents = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
gtk_box_set_spacing (GTK_BOX (dcontents), 5);
gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), GTK_RESPONSE_CLOSE, TRUE);
tmp = g_markup_printf_escaped ("<b>%s:</b>", act->name);
label = gtk_label_new ("");
gtk_label_set_markup (GTK_LABEL (label), tmp);
g_free (tmp);
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_box_pack_start (GTK_BOX (dcontents), label, FALSE, FALSE, 5);
fg = ui_formgrid_new (GDA_DATA_MODEL (result), TRUE,
GDAUI_DATA_PROXY_INFO_CURRENT_ROW);
ui_formgrid_set_connection (UI_FORMGRID (fg), tcnc);
ActionExecutedData *aed;
aed = g_new0 (ActionExecutedData, 1);
aed->formgrid = g_object_ref (formgrid);
aed->tcnc = g_object_ref (tcnc);
if (act->name)
aed->name = g_strdup (act->name);
aed->stmt = g_object_ref (act->stmt);
aed->params = g_object_ref (act->params);
if (GDA_IS_DATA_SELECT (result)) {
GdaStatement *stmt;
g_object_get (G_OBJECT (result), "select-stmt", &stmt, NULL);
if (stmt) {
ui_formgrid_handle_user_prefs (UI_FORMGRID (fg), NULL, stmt);
g_object_unref (stmt);
}
aed->model = g_object_ref (result);
g_signal_connect (aed->params, "holder-changed",
G_CALLBACK (action_executed_holder_changed_cb), aed);
aed->formgrid = g_object_ref (fg);
aed->formgrid->priv->autoupdate_possible = TRUE;
gtk_widget_show (aed->formgrid->priv->autoupdate_toggle);
}
gtk_box_pack_start (GTK_BOX (dcontents), fg, TRUE, TRUE, 0);
gtk_window_set_default_size (GTK_WINDOW (dialog), 400, 600);
gtk_widget_show_all (dialog);
g_signal_connect (dialog, "response",
G_CALLBACK (gtk_widget_destroy), NULL);
g_signal_connect (dialog, "close",
G_CALLBACK (gtk_widget_destroy), NULL);
g_object_set_data_full (G_OBJECT (dialog), "aed", aed,
(GDestroyNotify) action_executed_data_free);
}
else if (result) {
if (BROWSER_IS_WINDOW (toplevel)) {
browser_window_show_notice_printf (BROWSER_WINDOW (toplevel),
GTK_MESSAGE_INFO,
"ActionExecution",
"%s", _("Action successfully executed"));
}
else
ui_show_message (GTK_WINDOW (toplevel),
"%s", _("Action successfully executed"));
g_object_unref (result);
}
else {
ui_show_error (GTK_WINDOW (toplevel),
_("Error executing query: %s"),
lerror && lerror->message ? lerror->message : _("No detail"));
g_clear_error (&lerror);
}
}
}
/**
* gda_data_model_array_copy_model_ext:
* @src: a #GdaDataModel to copy data from
* @ncols: size of @cols
* @cols: (array length=ncols): array of @src's columns to copy into the new array, not %NULL
* @error: a place to store errors, or %NULL
*
* Like gda_data_model_array_copy_model(), makes a copy of @src, but copies only some
* columns.
*
* Returns: (transfer full) (allow-none): a new data model, or %NULL if an error occurred
*
* Since: 5.2.0
*/
GdaDataModelArray *
gda_data_model_array_copy_model_ext (GdaDataModel *src, gint ncols, gint *cols, GError **error)
{
GdaDataModel *model;
gint nbfields, i;
g_return_val_if_fail (GDA_IS_DATA_MODEL (src), NULL);
g_return_val_if_fail (cols, NULL);
g_return_val_if_fail (ncols > 0, NULL);
/* check columns' validity */
nbfields = gda_data_model_get_n_columns (src);
for (i = 0; i < ncols; i++) {
if ((cols[i] < 0) || (cols[i] >= nbfields)) {
g_set_error (error, GDA_DATA_MODEL_ERROR,
GDA_DATA_MODEL_COLUMN_OUT_OF_RANGE_ERROR,
_("Column %d out of range (0-%d)"), cols[i], nbfields - 1);
return NULL;
}
}
/* initialize new model */
model = gda_data_model_array_new (ncols);
if (g_object_get_data (G_OBJECT (src), "name"))
g_object_set_data_full (G_OBJECT (model), "name", g_strdup (g_object_get_data (G_OBJECT (src), "name")), g_free);
if (g_object_get_data (G_OBJECT (src), "descr"))
g_object_set_data_full (G_OBJECT (model), "descr", g_strdup (g_object_get_data (G_OBJECT (src), "descr")), g_free);
/* map new columns */
GHashTable *hash;
hash = g_hash_table_new_full (g_int_hash, g_int_equal, g_free, NULL);
for (i = 0; i < ncols; i++) {
gint *ptr;
ptr = g_new (gint, 1);
*ptr = i;
g_hash_table_insert (hash, ptr, GINT_TO_POINTER (cols[i]));
GdaColumn *copycol, *srccol;
gchar *colid;
srccol = gda_data_model_describe_column (src, cols[i]);
copycol = gda_data_model_describe_column (model, i);
g_object_get (G_OBJECT (srccol), "id", &colid, NULL);
g_object_set (G_OBJECT (copycol), "id", colid, NULL);
g_free (colid);
gda_column_set_description (copycol, gda_column_get_description (srccol));
gda_column_set_name (copycol, gda_column_get_name (srccol));
gda_column_set_dbms_type (copycol, gda_column_get_dbms_type (srccol));
gda_column_set_g_type (copycol, gda_column_get_g_type (srccol));
gda_column_set_position (copycol, gda_column_get_position (srccol));
gda_column_set_allow_null (copycol, gda_column_get_allow_null (srccol));
}
if (! gda_data_model_import_from_model (model, src, FALSE, hash, error)) {
g_hash_table_destroy (hash);
g_object_unref (model);
model = NULL;
}
/*else
gda_data_model_dump (model, stdout);*/
g_hash_table_destroy (hash);
return (GdaDataModelArray*) model;
}
/**
* 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;
}
