/*
* _gdaui_provider_auth_editor_set_provider
* @auth: a #GdauiProviderAuthEditor widget
* @provider: the provider to be used
*
* Updates the displayed fields in @auth to represent the required
* and possible arguments that a connection to a database through
* @provider would require
*/
void
_gdaui_provider_auth_editor_set_provider (GdauiProviderAuthEditor *auth, const gchar *provider)
{
g_return_if_fail (GDAUI_IS_PROVIDER_AUTH_EDITOR (auth));
g_return_if_fail (auth->priv);
auth->priv->pinfo = NULL;
if (auth->priv->provider)
g_free (auth->priv->provider);
auth->priv->provider = NULL;
auth->priv->auth_needed = FALSE;
if (auth->priv->auth_widget) {
gtk_widget_destroy (auth->priv->auth_widget);
auth->priv->auth_widget = NULL;
}
if (provider) {
auth->priv->pinfo = gda_config_get_provider_info (provider);
if (auth->priv->pinfo) {
auth->priv->provider = g_strdup (auth->priv->pinfo->id);
if (auth->priv->pinfo->auth_params && auth->priv->pinfo->auth_params->holders)
auth->priv->auth_needed = TRUE;
}
}
if (auth->priv->auth_needed) {
g_assert (auth->priv->pinfo);
GdaSet *set;
set = gda_set_copy (auth->priv->pinfo->auth_params);
auth->priv->auth_widget = gdaui_basic_form_new (set);
g_signal_connect (G_OBJECT (auth->priv->auth_widget), "holder-changed",
G_CALLBACK (auth_form_changed), auth);
g_object_unref (set);
}
if (auth->priv->auth_widget) {
gtk_container_add (GTK_CONTAINER (auth), auth->priv->auth_widget);
gtk_widget_show (auth->priv->auth_widget);
if (auth->priv->labels_size_group)
gdaui_basic_form_add_to_size_group (GDAUI_BASIC_FORM (auth->priv->auth_widget),
auth->priv->labels_size_group,
GDAUI_BASIC_FORM_LABELS);
if (auth->priv->entries_size_group)
gdaui_basic_form_add_to_size_group (GDAUI_BASIC_FORM (auth->priv->auth_widget),
auth->priv->entries_size_group,
GDAUI_BASIC_FORM_ENTRIES);
}
g_signal_emit_by_name (auth, "changed");
}
static void
adapt_form_widget (GdauiProviderSpecEditor *spec)
{
/* destroy any previous widget */
if (spec->priv->form) {
gtk_container_foreach (GTK_CONTAINER (spec), (GtkCallback) gtk_widget_destroy, NULL);
spec->priv->form = NULL;
}
spec->priv->type = NO_PROVIDER;
if (!spec->priv->provider)
return;
/* fetch DSN parameters */
GdaProviderInfo *pinfo;
pinfo = gda_config_get_provider_info (spec->priv->provider);
if (!pinfo) {
g_warning (_("Unknown provider '%s'"), spec->priv->provider);
return;
}
if (!pinfo->dsn_params) {
g_warning (_("Provider '%s' does not report the required parameters for DSN"), spec->priv->provider);
return;
}
/* create new widget */
GdaSet *dset;
dset = gda_set_copy (pinfo->dsn_params);
if (dset) {
GtkWidget *wid;
spec->priv->type = PROVIDER_FORM;
wid = gdaui_basic_form_new (dset);
g_object_set ((GObject*) wid, "show-actions", FALSE, NULL);
g_object_unref (dset);
spec->priv->form = wid;
if (spec->priv->labels_size_group)
gdaui_basic_form_add_to_size_group (GDAUI_BASIC_FORM (spec->priv->form), spec->priv->labels_size_group,
GDAUI_BASIC_FORM_LABELS);
if (spec->priv->entries_size_group)
gdaui_basic_form_add_to_size_group (GDAUI_BASIC_FORM (spec->priv->form), spec->priv->entries_size_group,
GDAUI_BASIC_FORM_ENTRIES);
update_form_contents (spec);
g_signal_connect (G_OBJECT (wid), "holder-changed",
G_CALLBACK (dsn_form_changed), spec);
gtk_widget_show (wid);
gtk_container_add (GTK_CONTAINER (spec), wid);
}
}
/**
* gda_repetitive_statement_append_set:
* @rstmt: a #GdaRepetitiveStatement object
* @values: a #GdaSet object with the values to be used
* @make_copy: %TRUE if @values is copied, and %FALSE if @values is only ref'ed
*
* Specifies that @rstmt be executed one time with the values contained in @values.
*
* A new #GdaSet to be used as the @values argument can be obtained using
* gda_repetitive_statement_get_template_set().
*
* Returns: a new #GdaRepetitiveStatement object
*
* Since: 4.2
*/
gboolean
gda_repetitive_statement_append_set (GdaRepetitiveStatement *rstmt, GdaSet *values, gboolean make_copy)
{
GdaSet *set;
g_return_val_if_fail (GDA_IS_REPETITIVE_STATEMENT(rstmt), FALSE);
g_return_val_if_fail (GDA_IS_SET (values), FALSE);
GdaRepetitiveStatementPrivate *priv = gda_repetitive_statement_get_instance_private (rstmt);
if (make_copy)
set = gda_set_copy (values);
else
set = g_object_ref (values);
priv->values_sets = g_slist_prepend (priv->values_sets, set);
return TRUE;
}
/**
* 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;
}
}
