/**
* Gets the list of items selected for saving by the user.
* @param dialog Exit dialog.
* @param items Structure to hold the selected items. Set to NULL if not items selected.
* @return The number of selected items.
*/
gint
get_selected_items (GtkWidget * dialog,
exit_dialog_item_array_t ** items)
{
GtkTreeView * treeview;
GtkTreeIter iter;
GtkListStore * model;
gboolean valid;
GSList * list = NULL;
GSList * list_iter;
gint selected_count;
gint i;
treeview = g_object_get_data (G_OBJECT (dialog), EXIT_DIALOG_TREEVIEW);
model = GTK_LIST_STORE (gtk_tree_view_get_model (treeview));
/* Get the first iter in the list */
valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (model), &iter);
/* Get the selected items */
while (valid)
{
const char * name;
const char * path;
gpointer data;
gboolean is_selected;
gtk_tree_model_get (GTK_TREE_MODEL (model), &iter,
CHECK_COL, &is_selected,
NAME_COL, &name,
PATH_COL, &path,
DATA_COL, &data,
-1);
if (is_selected)
{
exit_dialog_item_t * item = g_new (exit_dialog_item_t,1);
item->name = name;
item->path = path;
item->data = data;
list = g_slist_prepend (list, item);
}
valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (model), &iter);
}
selected_count = g_slist_length (list);
if (selected_count > 0)
{
*items = g_new (exit_dialog_item_array_t,1);
(*items)->array_size = selected_count;
(*items)->array = g_new (exit_dialog_item_t, (*items)->array_size);
list_iter = list;
for(i = 0 ; i < selected_count ; i++)
{
exit_dialog_item_t * item;
g_assert(list_iter!=NULL); /* can't be if g_slist_length works */
item = list_iter->data;
(*items)->array[i].name = item->name;
(*items)->array[i].path = item->path;
(*items)->array[i].data = item->data;
list_iter = g_slist_next(list_iter);
}
g_slist_free (list);
}
else
{
*items = NULL;
}
return selected_count;
}
static void
activate (GApplication *app)
{
GtkBuilder *builder;
GtkWindow *window;
GtkWidget *widget;
GtkTreeModel *model;
GtkTreeIter iter;
GError *error = NULL;
GtkWidget *sw;
GtkWidget *scrollbar;
GtkWidget *menu;
GtkWidget *item;
static GActionEntry win_entries[] = {
{ "run", activate_run, NULL, NULL, NULL }
};
builder = gtk_builder_new ();
gtk_builder_add_from_resource (builder, "/ui/main.ui", &error);
if (error != NULL)
{
g_critical ("%s", error->message);
exit (1);
}
window = (GtkWindow *)gtk_builder_get_object (builder, "window");
gtk_application_add_window (GTK_APPLICATION (app), window);
g_action_map_add_action_entries (G_ACTION_MAP (window),
win_entries, G_N_ELEMENTS (win_entries),
window);
notebook = (GtkWidget *)gtk_builder_get_object (builder, "notebook");
info_view = (GtkWidget *)gtk_builder_get_object (builder, "info-textview");
source_view = (GtkWidget *)gtk_builder_get_object (builder, "source-textview");
headerbar = (GtkWidget *)gtk_builder_get_object (builder, "headerbar");
treeview = (GtkWidget *)gtk_builder_get_object (builder, "treeview");
model = gtk_tree_view_get_model (GTK_TREE_VIEW (treeview));
sw = (GtkWidget *)gtk_builder_get_object (builder, "source-scrolledwindow");
scrollbar = gtk_scrolled_window_get_vscrollbar (GTK_SCROLLED_WINDOW (sw));
menu = gtk_menu_new ();
item = gtk_menu_item_new_with_label ("Start");
g_signal_connect (item, "activate", G_CALLBACK (start_cb), scrollbar);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
item = gtk_menu_item_new_with_label ("End");
g_signal_connect (item, "activate", G_CALLBACK (end_cb), scrollbar);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show_all (menu);
g_signal_connect (scrollbar, "popup-menu", G_CALLBACK (scrollbar_popup), menu);
load_file (gtk_demos[0].name, gtk_demos[0].filename);
populate_model (model);
g_signal_connect (treeview, "row-activated", G_CALLBACK (row_activated_cb), model);
widget = (GtkWidget *)gtk_builder_get_object (builder, "treeview-selection");
g_signal_connect (widget, "changed", G_CALLBACK (selection_cb), model);
gtk_tree_model_get_iter_first (gtk_tree_view_get_model (GTK_TREE_VIEW (treeview)), &iter);
gtk_tree_selection_select_iter (GTK_TREE_SELECTION (widget), &iter);
gtk_tree_view_collapse_all (GTK_TREE_VIEW (treeview));
gtk_widget_show_all (GTK_WIDGET (window));
g_object_unref (builder);
}
gboolean cardtree_is_empty(cardtree_t* ct)
{
GtkTreeIter iter;
return gtk_tree_model_get_iter_first(GTK_TREE_MODEL(ct->_store),&iter)==FALSE;
}
static int
banlist_unban_inner (gpointer none, struct session *sess, int do_exempts)
{
GtkTreeModel *model;
GtkTreeSelection *sel;
GtkTreeIter iter;
char tbuf[2048];
char **masks, *tmp, *space;
int num_sel, i;
/* grab the list of selected items */
model = GTK_TREE_MODEL (get_store (sess));
sel = gtk_tree_view_get_selection (get_view (sess));
num_sel = 0;
if (gtk_tree_model_get_iter_first (model, &iter))
{
do
{
if (gtk_tree_selection_iter_is_selected (sel, &iter))
num_sel++;
}
while (gtk_tree_model_iter_next (model, &iter));
}
if (num_sel < 1)
return 0;
/* create an array of all the masks */
masks = calloc (1, num_sel * sizeof (char *));
i = 0;
gtk_tree_model_get_iter_first (model, &iter);
do
{
if (gtk_tree_selection_iter_is_selected (sel, &iter))
{
gtk_tree_model_get (model, &iter, MASK_COLUMN, &masks[i], -1);
space = strchr (masks[i], ' ');
if (do_exempts)
{
if (space)
{
/* remove the "(EX) " */
tmp = masks[i];
masks[i] = g_strdup (space + 1);
g_free (tmp);
i++;
}
} else
{
if (!space)
i++;
}
}
}
while (gtk_tree_model_iter_next (model, &iter));
/* and send to server */
if (do_exempts)
send_channel_modes (sess, tbuf, masks, 0, i, '-', 'e', 0);
else
send_channel_modes (sess, tbuf, masks, 0, i, '-', 'b', 0);
/* now free everything, and refresh banlist */
for (i=0; i < num_sel; i++)
g_free (masks[i]);
free (masks);
return num_sel;
}
//! \brief try to fix some common errors in the csv representation of invoices
//! * corrects the date format
//! * corrects ambigous values in multi line invoices
//! * ensures customer exists
//! * if quantity is unset, set to 1
//! * if price is unset, delete row
void
gnc_bi_import_fix_bis (GtkListStore * store, guint * fixed, guint * deleted,
GString * info, gchar *type)
{
GtkTreeIter iter;
gboolean valid, row_deleted, row_fixed;
gchar *id = NULL, *date_opened = NULL, *date_posted = NULL, *due_date = NULL,
*owner_id = NULL, *date = NULL, *quantity = NULL, *price = NULL;
GString *prev_id, *prev_date_opened, *prev_date_posted, *prev_owner_id, *prev_date; // needed to fix multi line invoices
guint dummy;
gint row = 1;
const gchar* date_format_string = qof_date_format_get_string (qof_date_format_get()); // Get the user set date format string
//date_format_string = qof_date_format_get_string (qof_date_format_get());
DEBUG("date_format_string: %s",date_format_string);
// allow the call to this function with only GtkListeStore* specified
if (!fixed)
fixed = &dummy;
if (!deleted)
deleted = &dummy;
*fixed = 0;
*deleted = 0;
// init strings
prev_id = g_string_new ("");
prev_date_opened = g_string_new ("");
prev_date_posted = g_string_new ("");
prev_owner_id = g_string_new ("");
prev_date = g_string_new ("");
valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter);
while (valid)
{
row_deleted = FALSE;
row_fixed = FALSE;
// Walk through the list, reading each row
gtk_tree_model_get (GTK_TREE_MODEL (store), &iter,
ID, &id,
DATE_OPENED, &date_opened,
DATE_POSTED, &date_posted,
DUE_DATE, &due_date,
OWNER_ID, &owner_id,
DATE, &date,
QUANTITY, &quantity, PRICE, &price, -1);
if (strlen (price) == 0)
{
// invalid row (no price given)
// no fix possible -> delete row
valid = gtk_list_store_remove (store, &iter);
row_deleted = TRUE;
g_string_append_printf (info,
_("ROW %d DELETED, PRICE_NOT_SET: id=%s\n"),
row, id);
}
// TODO: QTY get set to 1 later if field is empty. Delete this section?
else if (strlen (quantity) == 0)
{
// invalid row (no quantity given)
// no fix possible -> delete row
valid = gtk_list_store_remove (store, &iter);
row_deleted = TRUE;
g_string_append_printf (info, _("ROW %d DELETED, QTY_NOT_SET: id=%s\n"),
row, id);
}
else
{ // TODO: If id is empty get the next one in the series. Bug 731105
if (strlen (id) == 0)
{
// no invoice id specified
if (prev_id->len == 0)
{
// cannot fix -> delete row
valid = gtk_list_store_remove (store, &iter);
row_deleted = TRUE;
g_string_append_printf (info,
_("ROW %d DELETED, ID_NOT_SET\n"), row);
}
else
{
// this is a fixable multi line invoice
gtk_list_store_set (store, &iter, ID, prev_id->str, -1);
row_fixed = TRUE;
}
}
else
{
// remember invoice id (to be able to fix multi line invoices)
g_string_assign (prev_id, id);
// new invoice => reset all other fixable entries
g_string_assign (prev_date_opened, "");
g_string_assign (prev_date_posted, "");
g_string_assign (prev_owner_id, "");
g_string_assign (prev_date, "");
}
}
if (!row_deleted)
{
// the row is valid (price and id are valid)
if(!isDateValid(date_opened))
{
if (prev_date_opened->len == 0)
{
// fix this by using the current date
gchar temp[20];
GDate date;
g_date_clear (&date, 1);
gnc_gdate_set_today (&date);
g_date_strftime (temp, 20, date_format_string, &date); // Create a user specified date string.
g_string_assign (prev_date_opened, temp);
}
// fix this by using the previous date_opened value (multi line invoice)
gtk_list_store_set (store, &iter, DATE_OPENED,
prev_date_opened->str, -1);
row_fixed = TRUE;
}
else
{
// remember date_opened (to be able to fix multi line invoices)
g_string_assign (prev_date_opened, date_opened);
}
// date_opened is valid
if(!isDateValid(date_posted))
{
if (prev_date_posted->len == 0)
{
// this invoice will have to get posted manually
}
else
{
// multi line invoice => fix it
gtk_list_store_set (store, &iter, DATE_POSTED,
prev_date_posted->str, -1);
row_fixed = TRUE;
}
}
else
{
// remember date_opened (to be able to fix multi line invoices)
g_string_assign (prev_date_posted, date_posted);
}
// date_posted is valid
/*
// Check if due date is valid. Set it to date_posted if not valid or missing.
if(!isDateValid(due_date))
{
gtk_list_store_set (store, &iter, DUE_DATE,
date_posted, -1);
row_fixed = TRUE;
}
// due_date is valid
*/
if (strlen (quantity) == 0)
{
// quantity is unset => set to 1
gtk_list_store_set (store, &iter, QUANTITY, "1", -1);
row_fixed = TRUE;
}
// quantity is valid
if (strlen (owner_id) == 0)
{
if (prev_owner_id->len == 0)
{
// no customer given and not fixable => delete row
valid = gtk_list_store_remove (store, &iter);
row_deleted = TRUE;
g_string_append_printf (info,
_("ROW %d DELETED, OWNER_NOT_SET: id=%s\n"),
row, id);
}
else
{
gtk_list_store_set (store, &iter, owner_id,
prev_owner_id->str, -1);
row_fixed = TRUE;
}
}
else
{
// remember owner_id
g_string_assign (prev_owner_id, owner_id);
}
if (g_ascii_strcasecmp (type, "BILL") == 0)
{
// BILL: check, if vendor exists
if (!gnc_search_vendor_on_id
(gnc_get_current_book (), prev_owner_id->str))
{
// vendor not found => delete row
valid = gtk_list_store_remove (store, &iter);
row_deleted = TRUE;
g_string_append_printf (info,
_("ROW %d DELETED, VENDOR_DOES_NOT_EXIST: id=%s\n"),
row, id);
}
}
else if (g_ascii_strcasecmp (type, "INVOICE") == 0)
{
// INVOICE: check, if customer exists
if (!gnc_search_customer_on_id
(gnc_get_current_book (), prev_owner_id->str))
{
// customer not found => delete row
valid = gtk_list_store_remove (store, &iter);
row_deleted = TRUE;
g_string_append_printf (info,
_("ROW %d DELETED, CUSTOMER_DOES_NOT_EXIST: id=%s\n"),
row, id);
}
}
// owner_id is valid
}
g_free (id);
g_free (date_opened);
g_free (date_posted);
g_free (owner_id);
g_free (date);
g_free (quantity);
g_free (price);
if (row_deleted)
{
(*deleted)++;
// reset all remembered values
g_string_assign (prev_id, "");
g_string_assign (prev_date_opened, "");
g_string_assign (prev_date_posted, "");
g_string_assign (prev_owner_id, "");
g_string_assign (prev_date, "");
}
else if (row_fixed)
(*fixed)++;
if (!row_deleted)
valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &iter);
row++;
}
// deallocate strings
g_string_free (prev_id, TRUE);
g_string_free (prev_date_opened, TRUE);
g_string_free (prev_date_posted, TRUE);
g_string_free (prev_owner_id, TRUE);
g_string_free (prev_date, TRUE);
if (info && (info->len > 0))
{
g_string_prepend (info, "\n\n");
g_string_prepend (info, _("These rows were deleted:"));
}
}
static gboolean
zimagez_upload_job (ScreenshooterJob *job, GArray *param_values, GError **error)
{
const gchar *encoded_data;
const gchar *image_path;
const gchar *last_user;
const gchar *proxy_uri;
/* For translators: the first wildcard is the date, the second one the time,
* e.g. "Taken on 12/31/99, at 23:13:48". */
gchar *comment = screenshooter_get_datetime (_("Taken on %x, at %X"));
gchar *data = NULL;
gchar *encoded_password = NULL;
gchar *file_name = NULL;
gchar *login_response = NULL;
gchar *online_file_name = NULL;
gchar *password = g_strdup ("");
gchar *title;
gchar *user;
gsize data_length;
gboolean response = FALSE;
const gchar *serverurl = "http://www.zimagez.com/apiXml.php";
const gchar *method_login = "******";
const gchar *method_logout = "apiXml.xmlrpcLogout";
const gchar *method_upload = "apiXml.xmlrpcUpload";
SoupSession *session;
SoupURI *soup_proxy_uri;
GError *tmp_error = NULL;
GtkTreeIter iter;
GtkListStore *liststore;
GValue response_value;
g_return_val_if_fail (SCREENSHOOTER_IS_JOB (job), FALSE);
g_return_val_if_fail (param_values != NULL, FALSE);
g_return_val_if_fail (param_values->len == 3, FALSE);
g_return_val_if_fail (G_VALUE_HOLDS_STRING (&g_array_index (param_values, GValue, 0)), FALSE);
g_return_val_if_fail (G_VALUE_HOLDS_STRING (&g_array_index (param_values, GValue, 1)), FALSE);
g_return_val_if_fail (G_VALUE_HOLDS_STRING (&g_array_index (param_values, GValue, 2)), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
g_object_set_data (G_OBJECT (job), "jobtype", "zimagez");
if (exo_job_set_error_if_cancelled (EXO_JOB (job), error))
{
g_free (comment);
g_free (password);
return FALSE;
}
/* Get the last user */
last_user = g_value_get_string (&g_array_index (param_values, GValue, 1));
user = g_strdup (last_user);
if (user == NULL)
user = g_strdup ("");
if (!g_utf8_validate (user, -1, NULL))
{
g_free (user);
user = g_strdup ("");
}
g_object_set_data_full (G_OBJECT (job), "user",
g_strdup (user), (GDestroyNotify) g_free);
/* Get the default title */
title = g_strdup (g_value_get_string (&g_array_index (param_values, GValue, 2)));
if (title == NULL)
title = g_strdup ("");
if (!g_utf8_validate (title, -1, NULL))
{
g_free (title);
title = g_strdup ("");
}
/* Get the path of the image that is to be uploaded */
image_path = g_value_get_string (&g_array_index (param_values, GValue, 0));
/* Start the user soup session */
exo_job_info_message (EXO_JOB (job), _("Initialize the connection..."));
session = soup_session_sync_new ();
/* Set the proxy URI if any */
proxy_uri = g_getenv ("http_proxy");
if (proxy_uri != NULL)
{
soup_proxy_uri = soup_uri_new (proxy_uri);
g_object_set (session, "proxy-uri", soup_proxy_uri, NULL);
soup_uri_free (soup_proxy_uri);
}
TRACE ("Get the information liststore ready.");
liststore = gtk_list_store_new (2, G_TYPE_INT, G_TYPE_STRING);
TRACE ("Append the user");
gtk_list_store_append (liststore, &iter);
gtk_list_store_set (liststore, &iter,
0, USER,
1, user,
-1);
TRACE ("Append the password");
gtk_list_store_append (liststore, &iter);
gtk_list_store_set (liststore, &iter,
0, PASSWORD,
1, password,
-1);
TRACE ("Append the title");
gtk_list_store_append (liststore, &iter);
gtk_list_store_set (liststore, &iter,
0, TITLE,
1, title,
-1);
TRACE ("Append the comment");
gtk_list_store_append (liststore, &iter);
gtk_list_store_set (liststore, &iter,
0, COMMENT,
1, comment,
-1);
TRACE ("Ask the user to fill the information items.");
screenshooter_job_ask_info (job, liststore,
_("Please fill the following fields with your "
"<a href=\"http://www.zimagez.com\">ZimageZ</a> \n"
"user name, passsword and details about the screenshot."));
gtk_tree_model_get_iter_first (GTK_TREE_MODEL (liststore), &iter);
do
{
gint field_index;
gchar *field_value = NULL;
gtk_tree_model_get (GTK_TREE_MODEL (liststore), &iter,
0, &field_index,
1, &field_value,
-1);
switch (field_index)
{
case USER:
user = g_strdup (field_value);
break;
case PASSWORD:
password = g_strdup (field_value);
break;
case TITLE:
title = g_strdup (field_value);
break;
case COMMENT:
comment = g_strdup (field_value);
break;
default:
break;
}
g_free (field_value);
}
while (gtk_tree_model_iter_next (GTK_TREE_MODEL (liststore), &iter));
while (!response)
{
if (exo_job_set_error_if_cancelled (EXO_JOB (job), error))
{
soup_session_abort (session);
g_object_unref (session);
g_free (user);
g_free (password);
g_free (title);
g_free (comment);
if (encoded_password != NULL)
g_free (encoded_password);
TRACE ("The upload job was cancelled.");
return FALSE;
}
exo_job_info_message (EXO_JOB (job), _("Check the user information..."));
/* Test if one of the information fields is empty */
if (has_empty_field (liststore))
{
TRACE ("One of the fields was empty, let the user file it.");
screenshooter_job_ask_info (job, liststore,
_("<span weight=\"bold\" foreground=\"darkred\" "
"stretch=\"semiexpanded\">You must fill all the "
"fields.</span>"));
continue;
}
encoded_password = g_utf8_strreverse (rot13 (password), -1);
TRACE ("User: %s", user);
TRACE ("Encoded password: %s", encoded_password);
/* Start the user session */
TRACE ("Call the login method");
exo_job_info_message (EXO_JOB (job), _("Login on ZimageZ..."));
if (!do_xmlrpc (session, serverurl, method_login,
&tmp_error, &response_value,
G_TYPE_STRING, user,
G_TYPE_STRING, encoded_password,
G_TYPE_INVALID))
{
g_propagate_error (error, tmp_error);
soup_session_abort (session);
g_object_unref (session);
g_free (password);
g_free (title);
g_free (comment);
g_free (encoded_password);
return FALSE;
}
TRACE ("Read the login response");
/* If the response is a boolean, there was an error */
if (G_VALUE_HOLDS_BOOLEAN (&response_value))
{
response = g_value_get_boolean (&response_value);
}
/* Else we read the string response to get the session ID */
else if (G_VALUE_HOLDS_STRING (&response_value))
{
TRACE ("Read the session ID");
login_response = g_strdup (g_value_get_string (&response_value));
response = TRUE;
}
/* We received an unexpected reply */
else
{
GError *tmp_err =
g_error_new (SOUP_XMLRPC_FAULT,
SOUP_XMLRPC_FAULT_PARSE_ERROR_NOT_WELL_FORMED,
"%s", _("An unexpected reply from ZimageZ was received."
" The upload of the screenshot failed."));
soup_session_abort (session);
g_object_unref (session);
g_free (user);
g_free (password);
g_free (title);
g_free (comment);
g_free (encoded_password);
g_propagate_error (error, tmp_err);
return FALSE;
}
g_value_unset (&response_value);
if (!response)
{
/* Login failed, erase the password and ask for the correct on to the
user */
gtk_tree_model_get_iter_first (GTK_TREE_MODEL (liststore), &iter);
do
{
gint field_index;
gtk_tree_model_get (GTK_TREE_MODEL (liststore), &iter, 0, &field_index, -1);
if (field_index == PASSWORD)
{
gtk_list_store_set (liststore, &iter, 1, g_strdup (""), -1);
break;
}
}
while (gtk_tree_model_iter_next (GTK_TREE_MODEL (liststore), &iter));
screenshooter_job_ask_info (job, liststore,
_("<span weight=\"bold\" foreground=\"darkred\" "
"stretch=\"semiexpanded\">The user and the "
"password you entered do not match. "
"Please retry.</span>"));
gtk_tree_model_get_iter_first (GTK_TREE_MODEL (liststore), &iter);
do
{
gint field_index;
gchar *field_value = NULL;
gtk_tree_model_get (GTK_TREE_MODEL (liststore), &iter,
0, &field_index,
1, &field_value,
-1);
switch (field_index)
{
case USER:
user = g_strdup (field_value);
break;
case PASSWORD:
password = g_strdup (field_value);
break;
case TITLE:
title = g_strdup (field_value);
break;
case COMMENT:
comment = g_strdup (field_value);
break;
default:
break;
}
g_free (field_value);
}
while (gtk_tree_model_iter_next (GTK_TREE_MODEL (liststore), &iter));
}
}
g_object_set_data_full (G_OBJECT (job), "user",
g_strdup (user), (GDestroyNotify) g_free);
g_free (user);
g_free (password);
g_free (encoded_password);
/* Get the contents of the image file and encode it to base64 */
g_file_get_contents (image_path, &data, &data_length, NULL);
encoded_data = g_base64_encode ((guchar*)data, data_length);
g_free (data);
/* Get the basename of the image path */
file_name = g_path_get_basename (image_path);
exo_job_info_message (EXO_JOB (job), _("Upload the screenshot..."));
TRACE ("Call the upload method");
do_xmlrpc (session, serverurl, method_upload,
&tmp_error, &response_value,
G_TYPE_STRING, encoded_data,
G_TYPE_STRING, file_name,
G_TYPE_STRING, title,
G_TYPE_STRING, comment,
G_TYPE_STRING, login_response,
G_TYPE_INVALID);
g_free (title);
g_free (comment);
g_free (file_name);
if (tmp_error)
{
soup_session_abort (session);
g_object_unref (session);
g_propagate_error (error, tmp_error);
return FALSE;
}
/* If the response is a boolean, there was an error */
if (G_VALUE_HOLDS_BOOLEAN (&response_value))
{
if (!g_value_get_boolean (&response_value))
{
GError *tmp_err =
g_error_new (G_IO_ERROR, G_IO_ERROR_FAILED,
_("An error occurred while uploading the screenshot."));
soup_session_abort (session);
g_object_unref (session);
g_propagate_error (error, tmp_err);
return FALSE;
}
}
/* Else we get the file name */
else if (G_VALUE_HOLDS_STRING (&response_value))
{
TRACE ("The screenshot has been uploaded, get the file name.");
online_file_name = g_strdup (g_value_get_string (&response_value));
}
/* We received un unexpected reply */
else
{
GError *tmp_err =
g_error_new (SOUP_XMLRPC_FAULT,
SOUP_XMLRPC_FAULT_PARSE_ERROR_NOT_WELL_FORMED,
"%s", _("An unexpected reply from ZimageZ was received."
" The upload of the screenshot failed."));
soup_session_abort (session);
g_object_unref (session);
g_propagate_error (error, tmp_err);
return FALSE;
}
g_value_unset (&response_value);
/* End the user session */
exo_job_info_message (EXO_JOB (job), _("Close the session on ZimageZ..."));
TRACE ("Closing the user session");
do_xmlrpc (session, serverurl, method_logout,
&tmp_error, &response_value,
G_TYPE_STRING, login_response,
G_TYPE_INVALID);
if (G_IS_VALUE (&response_value))
g_value_unset (&response_value);
/* Clean the soup session */
soup_session_abort (session);
g_object_unref (session);
g_free (login_response);
screenshooter_job_image_uploaded (job, online_file_name);
if (tmp_error)
{
g_propagate_error (error, tmp_error);
return FALSE;
}
return TRUE;
}
void
pidgin_xfer_dialog_update_xfer(PidginXferDialog *dialog,
PurpleXfer *xfer)
{
PidginXferUiData *data;
char *size_str, *remaining_str;
GtkTreeSelection *selection;
time_t current_time;
GtkTreeIter iter;
gboolean valid;
g_return_if_fail(dialog != NULL);
g_return_if_fail(xfer != NULL);
if ((data = PIDGINXFER(xfer)) == NULL)
return;
if (data->in_list == FALSE)
return;
current_time = time(NULL);
if (((current_time - data->last_updated_time) == 0) &&
(!purple_xfer_is_completed(xfer)))
{
/* Don't update the window more than once per second */
return;
}
data->last_updated_time = current_time;
size_str = purple_str_size_to_units(purple_xfer_get_size(xfer));
remaining_str = purple_str_size_to_units(purple_xfer_get_bytes_remaining(xfer));
gtk_list_store_set(xfer_dialog->model, &data->iter,
COLUMN_PROGRESS, purple_xfer_get_progress(xfer),
COLUMN_SIZE, size_str,
COLUMN_REMAINING, remaining_str,
-1);
g_free(size_str);
g_free(remaining_str);
if (purple_xfer_is_completed(xfer))
{
GdkPixbuf *pixbuf;
pixbuf = gtk_widget_render_icon(dialog->window,
PIDGIN_STOCK_FILE_DONE,
GTK_ICON_SIZE_MENU, NULL);
gtk_list_store_set(GTK_LIST_STORE(xfer_dialog->model), &data->iter,
COLUMN_STATUS, pixbuf,
COLUMN_REMAINING, _("Finished"),
-1);
g_object_unref(pixbuf);
}
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(xfer_dialog->tree));
update_title_progress(dialog);
if (xfer == dialog->selected_xfer)
update_detailed_info(xfer_dialog, xfer);
if (purple_xfer_is_completed(xfer) && dialog->auto_clear)
pidgin_xfer_dialog_remove_xfer(dialog, xfer);
else
update_buttons(dialog, xfer);
/*
* If all transfers are finished, and the pref is set, then
* close the dialog. Otherwise just exit this function.
*/
if (dialog->keep_open)
return;
valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(dialog->model), &iter);
while (valid)
{
GValue val;
PurpleXfer *next;
val.g_type = 0;
gtk_tree_model_get_value(GTK_TREE_MODEL(dialog->model),
&iter, COLUMN_DATA, &val);
next = g_value_get_pointer(&val);
if (!purple_xfer_is_completed(next))
return;
valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(dialog->model), &iter);
}
/* If we got to this point then we know everything is finished */
pidgin_xfer_dialog_hide(dialog);
}
static GObject*
close_confirmation_dialog_constructor (GType type,
guint n_construct_properties,
GObjectConstructParam *construct_params)
{
GObject *object;
CloseConfirmationDialog *dialog;
GtkWidget *hbox, *image, *vbox, *label;
GtkTreeIter iter;
gboolean ret, single_page;
gchar *tmp, *str;
const gchar *cstr;
/* chain up to constructor of parent class */
object =
G_OBJECT_CLASS (close_confirmation_dialog_parent_class)->constructor (
type,
n_construct_properties,
construct_params);
dialog = CLOSE_CONFIRMATION_DIALOG (object);
g_object_set (dialog,
/* GtkDialog */
"has-separator", FALSE,
/* GtkWindow */
"resizable", FALSE,
"skip-taskbar-hint", TRUE,
/* GtkContainer */
"border-width", 5,
NULL);
g_object_set (GTK_DIALOG (dialog)->vbox,
/* GtkBox */
"spacing", 14,
NULL);
g_object_set (GTK_DIALOG (dialog)->action_area,
/* GtkBox */
"spacing", 6,
/* GtkContainer */
"border-width", 5,
NULL);
/* check if there is one or more than one page with changes */
ret = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (
dialog->store_unsaved_pages),
&iter);
g_assert (ret);
single_page = !gtk_tree_model_iter_next (GTK_TREE_MODEL (
dialog->store_unsaved_pages),
&iter);
/* here starts the layout of the dialog */
hbox = GTK_WIDGET (g_object_new (GTK_TYPE_HBOX,
/* GtkContainer */
"border-width", 5,
/* GtkBox */
"homogeneous", FALSE,
"spacing", 12,
NULL));
/* warning image */
image = GTK_WIDGET (g_object_new (GTK_TYPE_IMAGE,
/* GtkMisc */
"xalign", 0.5,
"yalign", 0.0,
/* GtkImage */
"stock", GTK_STOCK_DIALOG_WARNING,
"icon-size", GTK_ICON_SIZE_DIALOG,
NULL));
gtk_box_pack_start (GTK_BOX (hbox), image,
FALSE, FALSE, 0);
/* vertical box on the right hand side of the dialog */
vbox = GTK_WIDGET (g_object_new (GTK_TYPE_VBOX,
/* GtkBox */
"homogeneous", FALSE,
"spacing", 12,
NULL));
/* primary label */
if (single_page) {
/* single page */
gchar *page_name;
page_name = get_page_name (GTK_TREE_MODEL (dialog->store_unsaved_pages),
NULL);
tmp = g_strdup_printf (
_("Save the changes to schematic \"%1$s\" before closing?"),
page_name);
g_free (page_name);
} else {
/* multi page */
tmp = g_strdup_printf (
_("There are %1$d schematics with unsaved changes. "
"Save changes before closing?"),
count_pages (GTK_TREE_MODEL (dialog->store_unsaved_pages)));
}
str = g_strconcat ("<big><b>", tmp, "</b></big>", NULL);
g_free (tmp);
label = GTK_WIDGET (g_object_new (GTK_TYPE_LABEL,
/* GtkMisc */
"xalign", 0.0,
"yalign", 0.0,
"selectable", TRUE,
/* GtkLabel */
"wrap", TRUE,
"use-markup", TRUE,
"label", str,
NULL));
g_free (str);
gtk_box_pack_start (GTK_BOX (vbox), label,
FALSE, FALSE, 0);
if (!single_page) {
/* more than one page with changes, display each page and offer */
/* the opportunity to save them before exiting */
gtk_box_pack_start (GTK_BOX (vbox),
close_confirmation_dialog_build_page_list (dialog),
FALSE, FALSE, 0);
}
/* secondary label */
cstr = _("If you don't save, all your changes will be permanently lost.");
label = GTK_WIDGET (g_object_new (GTK_TYPE_LABEL,
/* GtkMisc */
"xalign", 0.0,
"yalign", 0.0,
"selectable", TRUE,
/* GtkLabel */
"wrap", TRUE,
"label", cstr,
NULL));
gtk_box_pack_start (GTK_BOX (vbox), label,
FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), vbox,
FALSE, FALSE, 0);
/* add buttons to dialog action area */
gtk_dialog_add_buttons (GTK_DIALOG (dialog),
_("Close _without saving"), GTK_RESPONSE_NO,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_YES,
NULL);
/* Set the alternative button order (ok, cancel, help) for other systems */
gtk_dialog_set_alternative_button_order(GTK_DIALOG(dialog),
GTK_RESPONSE_YES,
GTK_RESPONSE_NO,
GTK_RESPONSE_CANCEL,
-1);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_YES);
/* all done, let's show the contents of the dialog */
gtk_widget_show_all (hbox);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox,
FALSE, FALSE, 0);
return object;
}
/**
* vdpdbg_window_update_lstRegList(): Update the VDP register list.
* @param reg_vdp VDP registers.
*/
static void vdpdbg_window_update_lstRegList(mdp_reg_vdp_t *reg_vdp)
{
// Go through the list and update the registers.
// TODO: If a user is editing a register, don't update that register.
GtkTreeIter iter;
int reg_num;
char hex_value[16];
char desc[1024];
uint8_t reg_value;
int prev_value;
// DMA Length and DMA Src Addr stuff.
GtkTreeIter iter_DMA_Len;
GtkTreeIter iter_DMA_Src;
gboolean DMA_Len_NeedsUpdate = FALSE;
gboolean DMA_Src_NeedsUpdate = FALSE;
gboolean valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(lmRegList), &iter);
while (valid)
{
gtk_tree_model_get(GTK_TREE_MODEL(lmRegList), &iter, 0, ®_num, 2, &prev_value, -1);
if (reg_num < 0 || reg_num >= 24)
{
// Invalid register number. Go to the next entry.
valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(lmRegList), &iter);
continue;
}
// TODO: If these aren't found but 20/22/23 are, an error will occur.
if (reg_num == 19)
iter_DMA_Len = iter;
else if (reg_num == 21)
iter_DMA_Src = iter;
// Get the register value.
// (prev_value == -1) means the register hasn't been updated yet.
// TODO: DMA Length and DMA Src Addr are multibyte values.
// With this method, they're only updated if the low byte is changed.
// Maybe they should be displayed in a different area...
reg_value = reg_vdp->data[reg_num];
if (prev_value != -1 && ((uint8_t)prev_value == reg_value))
{
// Register hasn't been changed. Skip it.
valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(lmRegList), &iter);
continue;
}
// Create the hexadecimal value.
szprintf(hex_value, sizeof(hex_value), "0x%02X", reg_value);
// Get the description.
vdpdbg_get_m5_reg_desc(reg_num, reg_value, reg_vdp, desc, sizeof(desc));
if (reg_num == 19 || reg_num == 20)
DMA_Len_NeedsUpdate = TRUE;
else if (reg_num >= 21 && reg_num <= 23)
DMA_Src_NeedsUpdate = TRUE;
// Set the value and description.
gtk_list_store_set(GTK_LIST_STORE(lmRegList), &iter,
2, reg_value, // Value.
3, hex_value, // Value (in hex).
4, desc, -1); // Description.
// Get the next list element.
valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(lmRegList), &iter);
}
// Check if DMA Length or DMA Src Address need to be updated.
if (DMA_Len_NeedsUpdate)
{
// DMA Length needs to be updated.
vdpdbg_get_m5_dma_len_desc(reg_vdp, desc, sizeof(desc));
gtk_list_store_set(GTK_LIST_STORE(lmRegList), &iter_DMA_Len, 4, desc, -1);
}
if (DMA_Src_NeedsUpdate)
{
// DMA Src Address needs to be updated.
vdpdbg_get_m5_dma_src_desc(reg_vdp, desc, sizeof(desc));
gtk_list_store_set(GTK_LIST_STORE(lmRegList), &iter_DMA_Src, 4, desc, -1);
}
}
void
gimp_scale_combo_box_set_scale (GimpScaleComboBox *combo_box,
gdouble scale)
{
GtkTreeModel *model;
GtkListStore *store;
GtkTreeIter iter;
gboolean iter_valid;
gboolean persistent;
g_return_if_fail (GIMP_IS_SCALE_COMBO_BOX (combo_box));
g_return_if_fail (scale > 0.0);
model = gtk_combo_box_get_model (GTK_COMBO_BOX (combo_box));
store = GTK_LIST_STORE (model);
for (iter_valid = gtk_tree_model_get_iter_first (model, &iter);
iter_valid;
iter_valid = gtk_tree_model_iter_next (model, &iter))
{
gdouble this;
gtk_tree_model_get (model, &iter,
SCALE, &this,
-1);
if (fabs (this - scale) < 0.0001)
break;
}
if (! iter_valid)
{
GtkTreeIter sibling;
for (iter_valid = gtk_tree_model_get_iter_first (model, &sibling);
iter_valid;
iter_valid = gtk_tree_model_iter_next (model, &sibling))
{
gdouble this;
gtk_tree_model_get (model, &sibling,
SCALE, &this,
-1);
if (this < scale)
break;
}
gtk_list_store_insert_before (store, &iter, iter_valid ? &sibling : NULL);
gimp_scale_combo_box_scale_iter_set (store, &iter, scale, FALSE);
}
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (combo_box), &iter);
gtk_tree_model_get (model, &iter,
PERSISTENT, &persistent,
-1);
if (! persistent)
{
gimp_scale_combo_box_mru_add (combo_box, &iter);
if (gtk_tree_model_iter_n_children (model, NULL) > MAX_ITEMS)
gimp_scale_combo_box_mru_remove_last (combo_box);
}
}
/**
* empathy_account_chooser_set_has_all_option:
* @chooser: an #EmpathyAccountChooser
* @has_all_option: a new value for the #EmpathyAccountChooser:has-all-option property
*
* Sets the #EmpathyAccountChooser:has-all-option property.
*/
void
empathy_account_chooser_set_has_all_option (EmpathyAccountChooser *chooser,
gboolean has_all_option)
{
EmpathyAccountChooserPriv *priv;
GtkComboBox *combobox;
GtkListStore *store;
GtkTreeModel *model;
GtkTreeIter iter;
g_return_if_fail (EMPATHY_IS_ACCOUNT_CHOOSER (chooser));
priv = GET_PRIV (chooser);
if (priv->has_all_option == has_all_option) {
return;
}
combobox = GTK_COMBO_BOX (chooser);
model = gtk_combo_box_get_model (combobox);
store = GTK_LIST_STORE (model);
priv->has_all_option = has_all_option;
/*
* The first 2 options are the ALL and separator
*/
if (has_all_option) {
gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (chooser),
(GtkTreeViewRowSeparatorFunc)
account_chooser_separator_func,
chooser,
NULL);
gtk_list_store_prepend (store, &iter);
gtk_list_store_set (store, &iter,
COL_ACCOUNT_TEXT, NULL,
COL_ACCOUNT_ENABLED, TRUE,
COL_ACCOUNT_POINTER, NULL,
COL_ACCOUNT_ROW_TYPE, ROW_SEPARATOR,
-1);
gtk_list_store_prepend (store, &iter);
gtk_list_store_set (store, &iter,
COL_ACCOUNT_TEXT, _("All accounts"),
COL_ACCOUNT_ENABLED, TRUE,
COL_ACCOUNT_POINTER, NULL,
COL_ACCOUNT_ROW_TYPE, ROW_ALL,
-1);
} else {
if (gtk_tree_model_get_iter_first (model, &iter)) {
if (gtk_list_store_remove (GTK_LIST_STORE (model), &iter)) {
gtk_list_store_remove (GTK_LIST_STORE (model), &iter);
}
}
gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (chooser),
(GtkTreeViewRowSeparatorFunc)
NULL,
NULL,
NULL);
}
g_object_notify (G_OBJECT (chooser), "has-all-option");
}
/**
* gtr_message_table_navigate:
* @table:
* @navigation:
* @func: (scope call):
*
* Returns: (transfer none):
*/
GtrMsg *
gtr_message_table_navigate (GtrMessageTable * table,
GtrMessageTableNavigation navigation,
GtrMessageTableNavigationFunc func)
{
GtkTreeSelection *selection;
GtkTreeModel *model;
GtkTreePath *path;
GtkTreeIter iter;
GtrMsg *msg;
gboolean cont = TRUE;
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (table->priv->treeview));
if (!gtk_tree_selection_get_selected (selection, &model, &iter))
return NULL;
switch (navigation)
{
case GTR_NAVIGATE_FIRST:
if (!gtk_tree_model_get_iter_first (model, &iter))
return NULL;
break;
case GTR_NAVIGATE_LAST:
{
gint n_children;
n_children = gtk_tree_model_iter_n_children (model, NULL);
if (n_children <= 0)
return NULL;
if (!gtk_tree_model_iter_nth_child (model, &iter, NULL, n_children - 1))
return NULL;
}
break;
case GTR_NAVIGATE_NEXT:
if (func)
{
while (cont)
{
if (!gtk_tree_model_iter_next (model, &iter))
return NULL;
gtk_tree_model_get (model, &iter,
GTR_MESSAGE_TABLE_MODEL_POINTER_COLUMN, &msg,
-1);
if (func (msg))
cont = FALSE;
}
}
else if (!gtk_tree_model_iter_next (model, &iter))
return NULL;
break;
case GTR_NAVIGATE_PREV:
if (func)
{
while (cont)
{
if (!gtk_tree_model_iter_previous (model, &iter))
return NULL;
gtk_tree_model_get (model, &iter,
GTR_MESSAGE_TABLE_MODEL_POINTER_COLUMN, &msg,
-1);
if (func (msg))
cont = FALSE;
}
}
else if (!gtk_tree_model_iter_previous (model, &iter))
return NULL;
break;
}
gtk_tree_selection_select_iter (selection, &iter);
path = gtk_tree_model_get_path (model, &iter);
gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (table->priv->treeview),
path, NULL, TRUE, 0.5, 0.0);
gtk_tree_model_get (model, &iter,
GTR_MESSAGE_TABLE_MODEL_POINTER_COLUMN, &msg,
-1);
return msg;
}
void
ghb_audio_list_refresh(signal_user_data_t *ud)
{
GtkTreeView *treeview;
GtkTreeIter iter;
GtkListStore *store;
gboolean done;
gint row = 0;
const GValue *audio_list;
g_debug("ghb_audio_list_refresh ()");
treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "audio_list"));
store = GTK_LIST_STORE(gtk_tree_view_get_model(treeview));
if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &iter))
{
do
{
const gchar *track, *codec, *br = NULL, *sr, *mix;
gchar *s_drc, *s_gain, *s_quality = NULL;
gdouble drc, gain;
GValue *asettings;
audio_list = ghb_settings_get_value(ud->settings, "audio_list");
if (row >= ghb_array_len(audio_list))
return;
asettings = ghb_array_get_nth(audio_list, row);
track = ghb_settings_combo_option(asettings, "AudioTrack");
codec = ghb_settings_combo_option(asettings, "AudioEncoderActual");
double quality = ghb_settings_get_double(asettings, "AudioTrackQuality");
if (ghb_settings_get_boolean(asettings, "AudioTrackQualityEnable") &&
quality != HB_INVALID_AUDIO_QUALITY)
{
int codec = ghb_settings_combo_int(asettings, "AudioEncoderActual");
s_quality = ghb_format_quality("Q/", codec, quality);
}
else
{
br = ghb_settings_get_string(asettings, "AudioBitrate");
}
sr = ghb_settings_combo_option(asettings, "AudioSamplerate");
mix = ghb_settings_combo_option(asettings, "AudioMixdown");
gain = ghb_settings_get_double(asettings, "AudioTrackGain");
s_gain = g_strdup_printf("%.fdB", gain);
drc = ghb_settings_get_double(asettings, "AudioTrackDRCSlider");
if (drc < 1.0)
s_drc = g_strdup("Off");
else
s_drc = g_strdup_printf("%.1f", drc);
gtk_list_store_set(GTK_LIST_STORE(store), &iter,
// These are displayed in list
0, track,
1, codec,
2, s_quality ? s_quality : br,
3, sr,
4, mix,
5, s_gain,
6, s_drc,
-1);
g_free(s_drc);
g_free(s_gain);
done = !gtk_tree_model_iter_next(GTK_TREE_MODEL(store), &iter);
row++;
} while (!done);
}
}
void keyword_hide_unset_in(GtkTreeStore *keyword_tree, gpointer id, GList *keywords)
{
GtkTreeIter iter;
if (!gtk_tree_model_get_iter_first(GTK_TREE_MODEL(keyword_tree), &iter)) return;
keyword_hide_unset_in_recursive(keyword_tree, &iter, id, keywords);
}
gboolean set_menu_contents( GtkTreeModel *model )
{
g_assert( GTK_IS_TREE_MODEL( model ) );
gboolean return_value = FALSE;
GtkTreeIter iter;
xmlBufferPtr buffer;
xmlTextWriterPtr writer;
gchar *user_home_dir = NULL;
gchar *user_menu_conf_file = NULL;
gchar *user_menu_dir = NULL;
FILE *fp;
/* Initialize libxml */
LIBXML_TEST_VERSION
/* OK, let's go! */
buffer = xmlBufferCreate();
if ( buffer == NULL ) {
g_warning( "set_menu_contents: failed to create xml buffer." );
return FALSE;
}
writer = xmlNewTextWriterMemory( buffer, 0 );
if ( writer == NULL ) {
g_warning( "set_menu_contents: failed to create xml writer." );
xmlBufferFree( buffer );
xmlCleanupParser();
return FALSE;
}
if ( xmlTextWriterStartDocument( writer, NULL, "UTF-8", NULL ) < 0 ) {
g_warning( "set_menu_contents: failed to start the document." );
goto cleanup_and_exit;
}
gtk_tree_model_get_iter_first (model, &iter);
if ( xmlTextWriterStartElement( writer,
BAD_CAST "Menu" ) < 0 ) {
g_warning ( "set_menu_contents: failed to write root element");
goto cleanup_and_exit;
}
if ( write_menu_conf( writer, GTK_TREE_STORE( model ), &iter ) == FALSE ) {
g_warning( "set_menu_contents: failed to write menu conf." );
goto cleanup_and_exit;
}
if ( xmlTextWriterEndElement( writer ) < 0 ) {
g_warning ( "set_menu_contents: failed to write root element");
goto cleanup_and_exit;
}
xmlTextWriterSetIndent( writer, 1 );
/* End the document */
if ( xmlTextWriterEndDocument( writer ) ) {
g_warning( "et_menu_contents: failed to end the document." );
goto cleanup_and_exit;
} else {
xmlFreeTextWriter( writer );
writer = NULL;
}
user_home_dir = getenv( "HOME" );
user_menu_conf_file = g_build_filename(
user_home_dir, USER_MENU_DIR, MENU_FILE, NULL );
/* Make sure we have the directory for user's menu file */
user_menu_dir = g_path_get_dirname( user_menu_conf_file );
if ( g_mkdir_with_parents( user_menu_dir, 0755 ) < 0 ) {
g_warning( "set_menu_contents: "
"failed to create directory '%s'.",
user_menu_dir );
goto cleanup_and_exit;
}
/* Always write to the user specific file */
fp = fopen(user_menu_conf_file, "w");
if (fp == NULL) {
g_warning( "set_menu_contents: failed to open '%s' for writing.",
user_menu_conf_file );
goto cleanup_and_exit;
} else {
g_debug( "set_menu_contents: writing to '%s'.", user_menu_conf_file );
return_value = TRUE;
}
fprintf(fp, "%s", (const char *) buffer->content);
fclose(fp);
cleanup_and_exit:
if ( writer ) {
xmlFreeTextWriter( writer );
}
xmlBufferFree( buffer );
xmlCleanupParser();
if ( user_menu_conf_file ) {
g_free( user_menu_conf_file );
}
if ( user_menu_dir ) {
g_free( user_menu_dir );
}
return return_value;
}
void
DictMngr::CreateReorderDialog()
{
GtkWidget *dialog, *selector;
GtkCellRenderer *renderer;
HildonTouchSelectorColumn *column;
GtkTreeModel *tree_model;
GtkTreeIter iter, iter2;
GtkTreePath *path;
gboolean iter_valid = TRUE;
std::list < std::string > selected_dict_list;
GtkListStore *dict_list = NULL;
const gint RESPONSE_FIRST = 1;
const gint RESPONSE_UP = 2;
const gint RESPONSE_DOWN = 3;
const gint RESPONSE_LAST = 4;
gint response;
dict_list = gtk_list_store_new(N_DICT_INFO_COLUMNS,
G_TYPE_STRING, /* bookname */
G_TYPE_STRING); /* filename */
/* create dialog */
dialog = gtk_dialog_new();
gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
gtk_window_set_title(GTK_WINDOW(dialog), _("Reorder"));
gtk_dialog_add_button(GTK_DIALOG(dialog), _("First"), RESPONSE_FIRST);
gtk_dialog_add_button(GTK_DIALOG(dialog), _("Up"), RESPONSE_UP);
gtk_dialog_add_button(GTK_DIALOG(dialog), _("Down"), RESPONSE_DOWN);
gtk_dialog_add_button(GTK_DIALOG(dialog), _("Last"), RESPONSE_LAST);
gtk_dialog_add_button(GTK_DIALOG(dialog), "OK", GTK_RESPONSE_ACCEPT);
gtk_window_set_default_size(GTK_WINDOW(dialog), -1, 400);
/* dictionary selector */
selector = hildon_touch_selector_new();
gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), selector);
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer),
"xpad", 10,
"ellipsize", PANGO_ELLIPSIZE_END,
"ellipsize-set", TRUE,
NULL);
column =
hildon_touch_selector_append_column(HILDON_TOUCH_SELECTOR
(selector),
GTK_TREE_MODEL(dict_list),
renderer, "text", BOOKNAME_DICT_INFO_COLUMN, NULL);
hildon_touch_selector_column_set_text_column(column, 0);
/* fill list with selected dictionaries */
oStarDict->oConf->GetStringList("/apps/maemo/mstardict/dict_list", selected_dict_list);
for (std::list < std::string >::iterator i = selected_dict_list.begin();
i != selected_dict_list.end(); ++i) {
DictInfo dictinfo;
dictinfo.load_from_ifo_file(i->c_str(), 0);
gtk_list_store_append(dict_list, &iter);
gtk_list_store_set(dict_list, &iter,
BOOKNAME_DICT_INFO_COLUMN,
dictinfo.bookname.c_str(), FILENAME_DICT_INFO_COLUMN, i->c_str(), -1);
}
g_object_unref(dict_list);
/* show dialog */
gtk_widget_show_all(GTK_WIDGET(dialog));
/* run the dialog */
while (TRUE) {
response = gtk_dialog_run(GTK_DIALOG(dialog));
switch(response) {
case RESPONSE_FIRST:
tree_model = hildon_touch_selector_get_model(HILDON_TOUCH_SELECTOR(selector), BOOKNAME_DICT_INFO_COLUMN);
if (hildon_touch_selector_get_selected(HILDON_TOUCH_SELECTOR(selector), BOOKNAME_DICT_INFO_COLUMN, &iter)) {
gtk_list_store_move_after(GTK_LIST_STORE(tree_model), &iter, NULL);
hildon_touch_selector_center_on_selected(HILDON_TOUCH_SELECTOR(selector));
}
break;
case RESPONSE_UP:
tree_model = hildon_touch_selector_get_model(HILDON_TOUCH_SELECTOR(selector), BOOKNAME_DICT_INFO_COLUMN);
if (hildon_touch_selector_get_selected(HILDON_TOUCH_SELECTOR(selector), BOOKNAME_DICT_INFO_COLUMN, &iter)) {
path = gtk_tree_model_get_path(tree_model, &iter);
gtk_tree_path_prev(path);
if (gtk_tree_model_get_iter(tree_model, &iter2, path)) {
gtk_list_store_swap(GTK_LIST_STORE(tree_model), &iter, &iter2);
}
gtk_tree_path_free(path);
hildon_touch_selector_center_on_selected(HILDON_TOUCH_SELECTOR(selector));
}
break;
case RESPONSE_DOWN:
tree_model = hildon_touch_selector_get_model(HILDON_TOUCH_SELECTOR(selector), BOOKNAME_DICT_INFO_COLUMN);
if (hildon_touch_selector_get_selected(HILDON_TOUCH_SELECTOR(selector), BOOKNAME_DICT_INFO_COLUMN, &iter)) {
path = gtk_tree_model_get_path(tree_model, &iter);
gtk_tree_path_next(path);
if (gtk_tree_model_get_iter(tree_model, &iter2, path)) {
gtk_list_store_swap(GTK_LIST_STORE(tree_model), &iter, &iter2);
}
gtk_tree_path_free(path);
hildon_touch_selector_center_on_selected(HILDON_TOUCH_SELECTOR(selector));
}
break;
case RESPONSE_LAST:
tree_model = hildon_touch_selector_get_model(HILDON_TOUCH_SELECTOR(selector), BOOKNAME_DICT_INFO_COLUMN);
if (hildon_touch_selector_get_selected(HILDON_TOUCH_SELECTOR(selector), BOOKNAME_DICT_INFO_COLUMN, &iter)) {
gtk_list_store_move_before(GTK_LIST_STORE(tree_model), &iter, NULL);
hildon_touch_selector_center_on_selected(HILDON_TOUCH_SELECTOR(selector));
}
break;
case GTK_RESPONSE_ACCEPT:
tree_model = hildon_touch_selector_get_model(HILDON_TOUCH_SELECTOR(selector), BOOKNAME_DICT_INFO_COLUMN);
iter_valid = gtk_tree_model_get_iter_first(tree_model, &iter);
selected_dict_list.clear();
while (iter_valid) {
const gchar *filename;
gtk_tree_model_get(GTK_TREE_MODEL(tree_model), &iter,
FILENAME_DICT_INFO_COLUMN, &filename, -1);
selected_dict_list.push_back(std::string(filename));
iter_valid = gtk_tree_model_iter_next(tree_model, &iter);
}
if (oStarDict->oConf->SetStringList("/apps/maemo/mstardict/dict_list", selected_dict_list)) {
/* reload dictionaries */
ReLoadDictionaries(selected_dict_list);
}
gtk_widget_destroy(GTK_WIDGET(dialog));
return;
default:
gtk_widget_destroy(GTK_WIDGET(dialog));
return;
}
}
}
static gchar*
rb_disc_recorder_plugin_write_audio_project (const gchar *name,
GtkTreeModel *model,
GError **error)
{
GtkTreeIter iter;
xmlTextWriter *project;
xmlDocPtr doc = NULL;
xmlSaveCtxt *save;
gint success;
gchar *path;
int fd;
int use_errno = 0;
if (! gtk_tree_model_get_iter_first (model, &iter)) {
g_set_error (error,
RB_RECORDER_ERROR,
RB_RECORDER_ERROR_GENERAL,
_("Unable to build an audio track list"));
return NULL;
}
/* get a temporary path */
path = g_build_filename (g_get_tmp_dir (), "brasero-tmp-project-XXXXXX", NULL);
fd = g_mkstemp (path);
if (fd == -1) {
g_set_error (error,
RB_RECORDER_ERROR,
RB_RECORDER_ERROR_GENERAL,
_("Unable to write audio project file %s: %s"),
path,
g_strerror (errno));
rb_debug ("g_mkstemp failed");
g_free (path);
return NULL;
}
project = xmlNewTextWriterDoc (&doc, 0);
if (!project) {
g_remove (path);
g_free (path);
close (fd);
g_set_error (error,
RB_RECORDER_ERROR,
RB_RECORDER_ERROR_GENERAL,
_("Unable to write audio project"));
return NULL;
}
xmlTextWriterSetIndent (project, 1);
xmlTextWriterSetIndentString (project, (xmlChar *) "\t");
success = xmlTextWriterStartDocument (project,
NULL,
"UTF8",
NULL);
if (success < 0)
goto error;
success = xmlTextWriterStartElement (project, (xmlChar *) "braseroproject");
if (success < 0)
goto error;
/* write the name of the version */
success = xmlTextWriterWriteElement (project,
(xmlChar *) "version",
(xmlChar *) "0.2");
if (success < 0)
goto error;
if (name) {
success = xmlTextWriterWriteElement (project,
(xmlChar *) "label",
(xmlChar *) name);
if (success < 0)
goto error;
}
success = xmlTextWriterStartElement (project, (xmlChar *) "track");
if (success < 0)
goto error;
success = xmlTextWriterStartElement (project, (xmlChar *) "audio");
if (success < 0)
goto error;
do {
RhythmDBEntry *entry;
const char *str;
xmlChar *escaped;
gtk_tree_model_get (model, &iter, 0, &entry, -1);
str = rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_LOCATION);
escaped = (xmlChar *) g_uri_escape_string (str, NULL, FALSE);
success = xmlTextWriterWriteElement (project,
(xmlChar *) "uri",
escaped);
g_free (escaped);
if (success == -1)
goto error;
/* start of the song always 0 */
success = xmlTextWriterWriteElement (project,
(xmlChar *) "start",
(xmlChar *) "0");
if (success == -1)
goto error;
/* end of the song = duration (in seconds while brasero likes it
* in nanoseconds =( ) */
/* Disable this for the moment and let brasero check the size
* itself. In case the user chooses on the fly burning we need
* a more precise duration or we'd end up burning the track
* incompletely or with a big padding */
/*
end = g_strdup_printf ("%"G_GINT64_FORMAT, (gint64) (song->duration * 1000000000LL));
success = xmlTextWriterWriteElement (project,
(xmlChar *) "end",
(xmlChar *) end);
g_free (end);
if (success == -1)
goto error;
*/
str = rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_TITLE);
if (str) {
escaped = (xmlChar *) g_uri_escape_string (str, NULL, FALSE);
success = xmlTextWriterWriteElement (project,
(xmlChar *) "title",
escaped);
g_free (escaped);
if (success == -1)
goto error;
}
str = rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_ARTIST);
if (str) {
escaped = (xmlChar *) g_uri_escape_string (str, NULL, FALSE);
success = xmlTextWriterWriteElement (project,
(xmlChar *) "artist",
escaped);
g_free (escaped);
if (success == -1)
goto error;
}
/*
if (song->composer) {
escaped = (unsigned char *) g_uri_escape_string (song->composer, NULL, FALSE);
success = xmlTextWriterWriteElement (project,
(xmlChar *) "composer",
escaped);
g_free (escaped);
if (success == -1)
goto error;
}
*/
} while (gtk_tree_model_iter_next (model, &iter));
success = xmlTextWriterEndElement (project); /* audio */
if (success < 0)
goto error;
success = xmlTextWriterEndElement (project); /* track */
if (success < 0)
goto error;
success = xmlTextWriterEndElement (project); /* braseroproject */
if (success < 0)
goto error;
success = xmlTextWriterEndDocument (project);
if (success < 0)
goto end_error;
xmlFreeTextWriter (project);
save = xmlSaveToFd (fd, "UTF8", XML_SAVE_FORMAT);
if (save == NULL)
goto save_error;
if (xmlSaveDoc (save, doc) == -1)
goto save_error;
if (xmlSaveClose (save) == -1) {
use_errno = errno;
rb_debug ("xmlSaveClose failed");
goto save_error;
}
xmlFreeDoc (doc);
if (close (fd) == -1) {
use_errno = errno;
rb_debug ("close() failed");
goto save_error;
}
return path;
error:
/* cleanup */
xmlTextWriterEndDocument (project);
end_error:
xmlFreeTextWriter (project);
save_error:
if (use_errno != 0) {
g_set_error (error,
RB_RECORDER_ERROR,
RB_RECORDER_ERROR_GENERAL,
_("Unable to write audio project file %s: %s"),
path,
g_strerror (use_errno));
} else {
g_set_error (error,
RB_RECORDER_ERROR,
RB_RECORDER_ERROR_GENERAL,
_("Unable to write audio project"));
}
g_remove (path);
g_free (path);
close (fd);
return NULL;
}
void
DictMngr::CreateDictMngrDialog()
{
GtkWidget *dialog, *selector;
GtkCellRenderer *renderer;
HildonTouchSelectorColumn *column;
GtkTreeModel *tree_model;
GtkTreeIter iter;
gboolean iter_valid = TRUE;
std::list < std::string > all_dict_list;
std::list < std::string > selected_dict_list;
GtkListStore *dict_list = NULL;
const gint RESPONSE_REORDER = 1;
gint response;
dict_list = gtk_list_store_new(N_DICT_INFO_COLUMNS,
G_TYPE_STRING, /* bookname */
G_TYPE_STRING); /* filename */
/* create dialog */
dialog = gtk_dialog_new();
gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
gtk_window_set_title(GTK_WINDOW(dialog), _("Dictionaries"));
gtk_dialog_add_button(GTK_DIALOG(dialog), _("Reorder"), RESPONSE_REORDER);
gtk_dialog_add_button(GTK_DIALOG(dialog), "OK", GTK_RESPONSE_ACCEPT);
gtk_window_set_default_size(GTK_WINDOW(dialog), -1, 400);
/* dictionary selector */
selector = hildon_touch_selector_new();
gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), selector);
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer),
"xpad", 10,
"ellipsize", PANGO_ELLIPSIZE_END,
"ellipsize-set", TRUE,
NULL);
column =
hildon_touch_selector_append_column(HILDON_TOUCH_SELECTOR
(selector),
GTK_TREE_MODEL(dict_list),
renderer, "text", BOOKNAME_DICT_INFO_COLUMN, NULL);
hildon_touch_selector_column_set_text_column(column, 0);
/* fill list with all available dictionaries */
GetAllDictionaryList(all_dict_list);
for (std::list < std::string >::iterator i = all_dict_list.begin();
i != all_dict_list.end(); ++i) {
DictInfo dictinfo;
dictinfo.load_from_ifo_file(i->c_str(), 0);
gtk_list_store_append(dict_list, &iter);
gtk_list_store_set(dict_list, &iter,
BOOKNAME_DICT_INFO_COLUMN,
dictinfo.bookname.c_str(), FILENAME_DICT_INFO_COLUMN, i->c_str(), -1);
}
g_object_unref(dict_list);
/* set selector mode to multiple */
hildon_touch_selector_set_column_selection_mode(HILDON_TOUCH_SELECTOR
(selector),
HILDON_TOUCH_SELECTOR_SELECTION_MODE_MULTIPLE);
hildon_touch_selector_unselect_all(HILDON_TOUCH_SELECTOR(selector), BOOKNAME_DICT_INFO_COLUMN);
/* select all load dictionaries */
tree_model =
hildon_touch_selector_get_model(HILDON_TOUCH_SELECTOR(selector), BOOKNAME_DICT_INFO_COLUMN);
for (iter_valid = gtk_tree_model_get_iter_first(tree_model, &iter);
iter_valid; iter_valid = gtk_tree_model_iter_next(tree_model, &iter)) {
const gchar *bookname;
gtk_tree_model_get(tree_model, &iter, BOOKNAME_DICT_INFO_COLUMN, &bookname, -1);
for (size_t iLib = 0; iLib < oStarDict->oLibs->query_dictmask.size(); iLib++) {
if (!strcmp(oStarDict->oLibs->dict_name(iLib).c_str(), bookname)) {
hildon_touch_selector_select_iter(HILDON_TOUCH_SELECTOR
(selector),
BOOKNAME_DICT_INFO_COLUMN, &iter, FALSE);
break;
}
}
}
/* show dialog */
gtk_widget_show_all(GTK_WIDGET(dialog));
/* run the dialog */
response = gtk_dialog_run(GTK_DIALOG(dialog));
if (response == GTK_RESPONSE_ACCEPT || response == RESPONSE_REORDER) {
GList *selected_dicts = NULL;
selected_dicts =
hildon_touch_selector_get_selected_rows(HILDON_TOUCH_SELECTOR
(selector), BOOKNAME_DICT_INFO_COLUMN);
if (selected_dicts) {
GList *dict = selected_dicts;
const gchar *filename;
while (dict) {
gtk_tree_model_get_iter(GTK_TREE_MODEL(tree_model), &iter,
(GtkTreePath *) (dict->data));
gtk_tree_model_get(GTK_TREE_MODEL(tree_model), &iter,
FILENAME_DICT_INFO_COLUMN, &filename, -1);
selected_dict_list.push_back(std::string(filename));
dict = dict->next;
}
g_list_foreach(selected_dicts, (GFunc) gtk_tree_path_free, NULL);
g_list_free(selected_dicts);
}
if (oStarDict->oConf->SetStringList("/apps/maemo/mstardict/dict_list", selected_dict_list)) {
/* reload dictionaries */
ReLoadDictionaries(selected_dict_list);
}
}
gtk_widget_destroy(GTK_WIDGET(dialog));
if (response == RESPONSE_REORDER) {
CreateReorderDialog();
}
}
void
cb_ask_for_information (ScreenshooterJob *job,
GtkListStore *liststore,
const gchar *message,
gpointer unused)
{
GtkWidget *dialog;
GtkWidget *information_label;
GtkWidget *vbox, *main_alignment;
GtkWidget *table;
GtkWidget *user_entry, *password_entry, *title_entry, *comment_entry;
GtkWidget *user_label, *password_label, *title_label, *comment_label;
GtkTreeIter iter;
gint response;
g_return_if_fail (SCREENSHOOTER_IS_JOB (job));
g_return_if_fail (GTK_IS_LIST_STORE (liststore));
g_return_if_fail (message != NULL);
TRACE ("Create the dialog to ask for user information.");
/* Create the information dialog */
dialog =
xfce_titled_dialog_new_with_buttons (_("Details about the screenshot for ZimageZ"),
NULL,
GTK_DIALOG_NO_SEPARATOR,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
GTK_STOCK_OK,
GTK_RESPONSE_OK,
NULL);
gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER);
gtk_box_set_spacing (GTK_BOX (GTK_DIALOG(dialog)->vbox), 12);
gtk_window_set_icon_name (GTK_WINDOW (dialog), "gtk-info");
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
/* Create the main alignment for the dialog */
main_alignment = gtk_alignment_new (0, 0, 1, 1);
gtk_alignment_set_padding (GTK_ALIGNMENT (main_alignment), 6, 0, 12, 12);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), main_alignment, TRUE, TRUE, 0);
/* Create the main box for the dialog */
vbox = gtk_vbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
gtk_container_add (GTK_CONTAINER (main_alignment), vbox);
/* Create the information label */
information_label = gtk_label_new ("");
gtk_label_set_markup (GTK_LABEL (information_label), message);
gtk_misc_set_alignment (GTK_MISC (information_label), 0, 0);
gtk_container_add (GTK_CONTAINER (vbox), information_label);
/* Create the layout table */
table = gtk_table_new (4, 2, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
gtk_table_set_row_spacings (GTK_TABLE (table), 12);
gtk_container_add (GTK_CONTAINER (vbox), table);
/* Create the user label */
user_label = gtk_label_new (_("User:"******"Your Zimagez user name, if you do not have one yet"
" please create one on the Web page linked above"));
gtk_entry_set_activates_default (GTK_ENTRY (user_entry), TRUE);
gtk_table_attach_defaults (GTK_TABLE (table), user_entry, 1, 2, 0, 1);
/* Create the password label */
password_label = gtk_label_new (_("Password:"******"The password for the user above"));
gtk_entry_set_visibility (GTK_ENTRY (password_entry), FALSE);
gtk_entry_set_activates_default (GTK_ENTRY (password_entry), TRUE);
gtk_table_attach_defaults (GTK_TABLE (table), password_entry, 1, 2, 1, 2);
/* Create the title label */
title_label = gtk_label_new (_("Title:"));
gtk_misc_set_alignment (GTK_MISC (title_label), 0, 0.5);
gtk_table_attach (GTK_TABLE (table), title_label,
0, 1,
2, 3,
GTK_FILL, GTK_FILL,
0, 0);
/* Create the title entry */
title_entry = gtk_entry_new ();
gtk_widget_set_tooltip_text (title_entry,
_("The title of the screenshot, it will be used when"
" displaying the screenshot on ZimageZ"));
gtk_entry_set_activates_default (GTK_ENTRY (title_entry), TRUE);
gtk_table_attach_defaults (GTK_TABLE (table), title_entry, 1, 2, 2, 3);
/* Create the comment label */
comment_label = gtk_label_new (_("Comment:"));
gtk_misc_set_alignment (GTK_MISC (comment_label), 0, 0.5);
gtk_table_attach (GTK_TABLE (table), comment_label,
0, 1,
3, 4,
GTK_FILL, GTK_FILL,
0, 0);
/* Create the comment entry */
comment_entry = gtk_entry_new ();
gtk_widget_set_tooltip_text (comment_entry,
_("A comment on the screenshot, it will be used when"
" displaying the screenshot on ZimageZ"));
gtk_entry_set_activates_default (GTK_ENTRY (comment_entry), TRUE);
gtk_table_attach_defaults (GTK_TABLE (table), comment_entry, 1, 2, 3, 4);
/* Set the values */
gtk_tree_model_get_iter_first (GTK_TREE_MODEL (liststore), &iter);
do
{
gint field_index;
gchar *field_value = NULL;
gtk_tree_model_get (GTK_TREE_MODEL (liststore), &iter,
0, &field_index,
1, &field_value,
-1);
switch (field_index)
{
case USER:
gtk_entry_set_text (GTK_ENTRY (user_entry), field_value);
break;
case PASSWORD:
gtk_entry_set_text (GTK_ENTRY (password_entry), field_value);
break;
case TITLE:
gtk_entry_set_text (GTK_ENTRY (title_entry), field_value);
break;
case COMMENT:
gtk_entry_set_text (GTK_ENTRY (comment_entry), field_value);
break;
default:
break;
}
g_free (field_value);
}
while (gtk_tree_model_iter_next (GTK_TREE_MODEL (liststore), &iter));
gtk_widget_show_all (GTK_DIALOG(dialog)->vbox);
response = gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_hide (dialog);
if (response == GTK_RESPONSE_CANCEL || response == GTK_RESPONSE_DELETE_EVENT)
{
exo_job_cancel (EXO_JOB (job));
}
else if (response == GTK_RESPONSE_OK)
{
gtk_tree_model_get_iter_first (GTK_TREE_MODEL (liststore), &iter);
do
{
gint field_index;
gtk_tree_model_get (GTK_TREE_MODEL (liststore), &iter,
0, &field_index, -1);
switch (field_index)
{
case USER:
gtk_list_store_set (liststore, &iter,
1, gtk_entry_get_text (GTK_ENTRY (user_entry)),
-1);
break;
case PASSWORD:
gtk_list_store_set (liststore, &iter,
1, gtk_entry_get_text (GTK_ENTRY (password_entry)),
-1);
break;
case TITLE:
gtk_list_store_set (liststore, &iter,
1, gtk_entry_get_text (GTK_ENTRY (title_entry)),
-1);
break;
case COMMENT:
gtk_list_store_set (liststore, &iter,
1, gtk_entry_get_text (GTK_ENTRY (comment_entry)),
-1);
break;
default:
break;
}
}
while (gtk_tree_model_iter_next (GTK_TREE_MODEL (liststore), &iter));
}
gtk_widget_destroy (dialog);
}
static void
run_automated_tests (void)
{
g_print ("Running automated tests...\n");
/* FIXME TreePath basic verification */
/* FIXME generic consistency checks on the models */
{
/* Make sure list store mutations don't crash anything */
GtkListStore *store;
GtkTreeModel *model;
gint i;
GtkTreeIter iter;
store = gtk_list_store_new (1, G_TYPE_INT);
model = GTK_TREE_MODEL (store);
i = 0;
while (i < 100)
{
gtk_list_store_append (store, &iter);
++i;
}
while (gtk_tree_model_get_iter_first (model, &iter))
gtk_list_store_remove (store, &iter);
gtk_list_store_append (store, &iter);
/* inserts before last node in list */
i = 0;
while (i < 100)
{
gtk_list_store_insert_before (store, &iter, &iter);
++i;
}
/* inserts after the node before the last node */
i = 0;
while (i < 100)
{
gtk_list_store_insert_after (store, &iter, &iter);
++i;
}
/* inserts after the last node */
gtk_list_store_append (store, &iter);
i = 0;
while (i < 100)
{
gtk_list_store_insert_after (store, &iter, &iter);
++i;
}
/* remove everything again */
while (gtk_tree_model_get_iter_first (model, &iter))
gtk_list_store_remove (store, &iter);
/* Prepends */
gtk_list_store_prepend (store, &iter);
i = 0;
while (i < 100)
{
gtk_list_store_prepend (store, &iter);
++i;
}
/* remove everything again */
while (gtk_tree_model_get_iter_first (model, &iter))
gtk_list_store_remove (store, &iter);
g_object_unref (store);
}
{
/* Make sure tree store mutations don't crash anything */
GtkTreeStore *store;
GtkTreeIter root;
store = gtk_tree_store_new (1, G_TYPE_INT);
gtk_tree_store_append (GTK_TREE_STORE (store), &root, NULL);
/* Remove test until it is rewritten to work */
/* treestore_torture_recurse (store, &root, 0);*/
g_object_unref (store);
}
g_print ("Passed.\n");
}
static void prefs_ok_cb(GtkWidget *widget, gpointer data)
{
gchar *rcpath;
const gchar *address;
gboolean startup;
gboolean unreadonly;
GtkTreeModel *model;
gint nfolder;
gchar **folders;
GtkTreeIter iter;
gboolean valid;
int nindex;
gchar *folder;
gsize sz;
gchar *buf;
rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, "autoforwardrc", NULL);
g_keyfile = g_key_file_new();
g_key_file_load_from_file(g_keyfile, rcpath, G_KEY_FILE_KEEP_COMMENTS, NULL);
address = gtk_entry_get_text(GTK_ENTRY(g_address));
if (address!=NULL){
g_key_file_set_string (g_keyfile, "forward", "to", address);
}
startup = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(g_startup));
g_key_file_set_boolean (g_keyfile, "forward", "startup", startup);
debug_print("startup:%s\n", startup ? "true" : "false");
unreadonly = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(g_unreadonly));
g_key_file_set_boolean (g_keyfile, "forward", "unreadonly", unreadonly);
debug_print("unread only:%s\n", g_unreadonly_flg ? "true" : "false");
g_key_file_set_boolean (g_keyfile, "forward", "all", g_forward_flg);
debug_print("forward all:%s\n", g_forward_flg ? "true" : "false");
/**/
model = GTK_TREE_MODEL(g_folders);
nfolder = gtk_tree_model_iter_n_children(model, NULL);
if (nfolder > 0){
folders = malloc(sizeof(gchar*)*nfolder);
nindex = 0;
for (valid = gtk_tree_model_get_iter_first(model, &iter); valid;
valid = gtk_tree_model_iter_next(model, &iter)) {
gtk_tree_model_get(model, &iter, 0, &folder, -1);
folders[nindex] = folder;
g_print("%d:%s\n", nindex, folder);
nindex++;
}
g_key_file_set_string_list(g_keyfile, "forward", "folder",
(const gchar * const*)folders, nfolder);
}else{
g_key_file_remove_key(g_keyfile, "forward", "folder", NULL);
}
buf=g_key_file_to_data(g_keyfile, &sz, NULL);
g_file_set_contents(rcpath, buf, sz, NULL);
g_free(rcpath);
gtk_widget_destroy(GTK_WIDGET(data));
}
static void
cg_cell_renderer_flags_editing_done (GtkCellEditable *editable,
G_GNUC_UNUSED gpointer data)
{
CgCellRendererFlags *cell_flags;
CgCellRendererFlagsPrivate *priv;
const gchar *path;
GString *str;
gchar *abbr;
GtkTreeIter iter;
gboolean result;
gboolean canceled;
cell_flags = CG_CELL_RENDERER_FLAGS (data);
priv = CG_CELL_RENDERER_FLAGS_PRIVATE (cell_flags);
g_assert (priv->edit_status != NULL);
if (priv->focus_out_id > 0)
{
g_signal_handler_disconnect (G_OBJECT (editable), priv->focus_out_id);
priv->focus_out_id = 0;
}
canceled = cg_combo_flags_editing_canceled (CG_COMBO_FLAGS (editable));
gtk_cell_renderer_stop_editing (GTK_CELL_RENDERER(cell_flags), canceled);
if (canceled == FALSE)
{
str = g_string_sized_new (128);
/* We do not just call g_hash_table_foreach to get the flags
* in the correct order. */
for (result = gtk_tree_model_get_iter_first (priv->model, &iter);
result != FALSE;
result = gtk_tree_model_iter_next (priv->model, &iter))
{
gtk_tree_model_get (priv->model, &iter,
priv->abbr_column, &abbr, -1);
if (g_hash_table_lookup (priv->edit_status, abbr) != NULL)
{
if (str->len > 0) g_string_append_c (str, '|');
g_string_append (str, abbr);
}
g_free (abbr);
}
path = g_object_get_data (G_OBJECT (editable),
CG_CELL_RENDERER_FLAGS_PATH);
g_signal_emit_by_name (G_OBJECT (cell_flags), "edited",
path, str->str);
g_string_free (str, TRUE);
}
g_hash_table_destroy (priv->edit_status);
priv->edit_status = NULL;
}
static gboolean ui_authenticate(dt_storage_facebook_gui_data_t *ui)
{
if (ui->facebook_api == NULL)
{
ui->facebook_api = fb_api_init();
}
FBContext *ctx = ui->facebook_api;
gboolean mustsaveaccount = FALSE;
gchar *uiselectedaccounttoken = NULL;
GtkTreeIter iter;
gtk_combo_box_get_active_iter(ui->comboBox_username, &iter);
GtkTreeModel *accountModel = gtk_combo_box_get_model(ui->comboBox_username);
gtk_tree_model_get(accountModel, &iter, 1, &uiselectedaccounttoken, -1);
if (ctx->token != NULL)
{
g_free(ctx->token);
ctx->token = NULL;
}
if (uiselectedaccounttoken != NULL)
{
ctx->token = g_strdup(uiselectedaccounttoken);
}
//check selected token if we already have one
if (ctx->token != NULL && !fb_test_auth_token(ctx))
{
g_free(ctx->token);
ctx->token = NULL;
}
if(ctx->token == NULL)
{
mustsaveaccount = TRUE;
ctx->token = facebook_get_user_auth_token(ui);//ask user to log in
}
if (ctx->token == NULL)
{
return FALSE;
}
else
{
if (mustsaveaccount)
{
FBAccountInfo *accountinfo = fb_get_account_info(ui->facebook_api);
g_return_val_if_fail(accountinfo != NULL, FALSE);
save_account_info(ui, accountinfo);
//add account to user list and select it
GtkListStore *model = GTK_LIST_STORE(gtk_combo_box_get_model(ui->comboBox_username));
GtkTreeIter iter;
gboolean r;
gchar *uid;
gboolean updated = FALSE;
for (r = gtk_tree_model_get_iter_first (GTK_TREE_MODEL(model), &iter);
r == TRUE;
r = gtk_tree_model_iter_next (GTK_TREE_MODEL(model), &iter))
{
gtk_tree_model_get (GTK_TREE_MODEL(model), &iter, COMBO_USER_MODEL_ID_COL, &uid, -1);
if (g_strcmp0(uid, accountinfo->id) == 0)
{
gtk_list_store_set(model, &iter, COMBO_USER_MODEL_NAME_COL, accountinfo->username,
COMBO_USER_MODEL_TOKEN_COL, accountinfo->token,
-1);
updated = TRUE;
break;
}
}
if (!updated)
{
gtk_list_store_append(model, &iter);
gtk_list_store_set(model, &iter, COMBO_USER_MODEL_NAME_COL, accountinfo->username,
COMBO_USER_MODEL_TOKEN_COL, accountinfo->token,
COMBO_USER_MODEL_ID_COL, accountinfo->id, -1);
}
gtk_combo_box_set_active_iter(ui->comboBox_username, &iter);
//we have to re-set the current token here since ui_combo_username_changed is called
//on gtk_combo_box_set_active_iter (and thus is resetting the active token)
ctx->token = g_strdup(accountinfo->token);
fb_account_info_destroy(accountinfo);
}
return TRUE;
}
}
/*
* This function sets the custom list when the language list has changed in
* the language dialog (launched from language button or F10 menu).
*/
void
lang_set_custom_callback (gchar *language)
{
GtkListStore *lang_model = mdm_lang_get_model ();
GtkTreeIter iter;
gboolean valid;
char *locale_name;
int i=0;
/* Do nothing if there is no language widget */
if (language_widget == NULL)
return;
/*
* Handle for either combo box or list style, depending on which is being
* used.
. */
if (GTK_IS_COMBO_BOX (language_widget))
{
valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (lang_model),
&iter);
while (valid)
{
gtk_tree_model_get (GTK_TREE_MODEL (lang_model), &iter,
LOCALE_COLUMN, &locale_name, -1);
if (strcmp (language, locale_name) == 0)
{
gtk_combo_box_set_active (GTK_COMBO_BOX (language_widget), i);
break;
}
valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (lang_model), &iter);
i++;
}
}
else if (GTK_IS_SCROLLED_WINDOW (language_widget) &&
GTK_IS_TREE_VIEW (GTK_BIN (language_widget)->child))
{
GtkTreeView *tv = GTK_TREE_VIEW (GTK_BIN (language_widget)->child);
GtkTreeModel *tm = gtk_tree_view_get_model (tv);
GtkTreeSelection *selection = gtk_tree_view_get_selection (tv);
GtkTreeIter loopiter;
if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (tm), &loopiter))
{
do
{
char *locale_file;
gtk_tree_model_get (GTK_TREE_MODEL (tm), &loopiter, GREETER_LIST_ID, &locale_file, -1);
if (locale_file != NULL && strcmp (language, locale_file) == 0)
{
GtkTreePath *path = gtk_tree_model_get_path (tm, &loopiter);
gtk_tree_selection_select_iter (selection, &loopiter);
gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (tv),
path, NULL,
FALSE, 0.0, 0.0);
gtk_tree_path_free (path);
break;
}
} while (gtk_tree_model_iter_next (GTK_TREE_MODEL (tm), &loopiter));
}
}
}
/***********************************************************************
* @todo Maybe invoice checking should be done in gnc_bi_import_fix_bis (...)
* rather than in here? But that is more concerned with ensuring the csv is consistent.
* @param GtkListStore *store
* @param guint *n_invoices_created
* @param guint *n_invoices_updated
* @return void
***********************************************************************/
void
gnc_bi_import_create_bis (GtkListStore * store, QofBook * book,
guint * n_invoices_created,
guint * n_invoices_updated,
gchar * type, gchar * open_mode, GString * info)
{
gboolean valid;
GtkTreeIter iter;
gchar *id = NULL, *date_opened = NULL, *owner_id = NULL, *billing_id = NULL, *notes = NULL;
gchar *date = NULL, *desc = NULL, *action = NULL, *account = NULL, *quantity = NULL,
*price = NULL, *disc_type = NULL, *disc_how = NULL, *discount = NULL, *taxable = NULL,
*taxincluded = NULL, *tax_table = NULL;
gchar *date_posted = NULL, *due_date = NULL, *account_posted = NULL, *memo_posted = NULL,
*accumulatesplits = NULL;
guint dummy;
GncInvoice *invoice;
GncEntry *entry;
gint day, month, year;
gnc_numeric value;
GncOwner *owner;
Account *acc;
enum update {YES = GTK_RESPONSE_YES, NO = GTK_RESPONSE_NO} update;
GtkWidget *dialog;
Timespec today;
InvoiceWindow *iw;
gchar *new_id = NULL;
gint64 denom = 0;
gnc_commodity *currency;
// these arguments are needed
g_return_if_fail (store && book);
// logic of this function only works for bills or invoices
g_return_if_fail ((g_ascii_strcasecmp (type, "INVOICE") == 0) ||
(g_ascii_strcasecmp (type, "BILL") == 0));
// allow to call this function without statistics
if (!n_invoices_created)
n_invoices_created = &dummy;
if (!n_invoices_updated)
n_invoices_updated = &dummy;
*n_invoices_created = 0;
*n_invoices_updated = 0;
invoice = NULL;
update = NO;
valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter);
while (valid)
{
// Walk through the list, reading each row
gtk_tree_model_get (GTK_TREE_MODEL (store), &iter,
ID, &id,
DATE_OPENED, &date_opened,
DATE_POSTED, &date_posted, // if autoposting requested
DUE_DATE, &due_date, // if autoposting requested
ACCOUNT_POSTED, &account_posted, // if autoposting requested
MEMO_POSTED, &memo_posted, // if autoposting requested
ACCU_SPLITS, &accumulatesplits, // if autoposting requested
OWNER_ID, &owner_id,
BILLING_ID, &billing_id,
NOTES, ¬es,
DATE, &date,
DESC, &desc,
ACTION, &action,
ACCOUNT, &account,
QUANTITY, &quantity,
PRICE, &price,
DISC_TYPE, &disc_type,
DISC_HOW, &disc_how,
DISCOUNT, &discount,
TAXABLE, &taxable,
TAXINCLUDED, &taxincluded,
TAX_TABLE, &tax_table, -1);
// TODO: Assign a new invoice number if one is absent. BUT we don't want to assign a new invoice for every line!!
// so we'd have to flag this up somehow or add an option in the import GUI. The former implies that we make
// an assumption about what the importer (person) wants to do. It seems reasonable that a CSV file full of items with
// If an invoice exists then we add to it in this current schema.
// no predefined invoice number is a new invoice that's in need of a new number.
// This was not designed to satisfy the need for repeat invoices however, so maybe we need a another method for this, after all
// It should be easier to copy an invoice with a new ID than to go through all this malarky.
if (g_ascii_strcasecmp (type, "BILL") == 0)
invoice = gnc_search_bill_on_id (book, id);
else if (g_ascii_strcasecmp (type, "INVOICE") == 0)
invoice = gnc_search_invoice_on_id (book, id);
DEBUG( "Existing %s ID: %s\n", type, gncInvoiceGetID(invoice));
// If the search is empty then there is no existing invoice so make a new one
if (invoice == NULL)
{
DEBUG( "Creating a new : %s\n", type );
// new invoice
invoice = gncInvoiceCreate (book);
/* Protect against thrashing the DB and trying to write the invoice
* record prematurely */
gncInvoiceBeginEdit (invoice);
gncInvoiceSetID (invoice, id);
owner = gncOwnerNew ();
if (g_ascii_strcasecmp (type, "BILL") == 0)
gncOwnerInitVendor (owner,
gnc_search_vendor_on_id (book, owner_id));
else if (g_ascii_strcasecmp (type, "INVOICE") == 0)
gncOwnerInitCustomer (owner,
gnc_search_customer_on_id (book, owner_id));
gncInvoiceSetOwner (invoice, owner);
gncInvoiceSetCurrency (invoice, gncOwnerGetCurrency (owner)); // Set the invoice currency based on the owner
if (strlen (date_opened) != 0) // If a date is specified in CSV
{
// FIXME: Must check for the return value of qof_scan_date!
qof_scan_date (date_opened, &day, &month, &year);
gncInvoiceSetDateOpened (invoice,
gnc_dmy2timespec (day, month, year));
}
else // If no date in CSV
{
time64 now = gnc_time (NULL);
Timespec now_timespec;
timespecFromTime64 (&now_timespec, now);
gncInvoiceSetDateOpened (invoice, now_timespec);
}
gncInvoiceSetBillingID (invoice, billing_id ? billing_id : "");
notes = un_escape(notes);
gncInvoiceSetNotes (invoice, notes ? notes : "");
gncInvoiceSetActive (invoice, TRUE);
//if (g_ascii_strcasecmp(type,"INVOICE"))gncInvoiceSetBillTo( invoice, billto );
(*n_invoices_created)++;
update = YES;
// open new bill / invoice in a tab, if requested
if (g_ascii_strcasecmp(open_mode, "ALL") == 0
|| (g_ascii_strcasecmp(open_mode, "NOT_POSTED") == 0
&& strlen(date_posted) == 0))
{
iw = gnc_ui_invoice_edit (invoice);
gnc_plugin_page_invoice_new (iw);
}
gncInvoiceCommitEdit (invoice);
}
// I want to warn the user that an existing billvoice exists, but not every
// time.
// An import can contain many lines usually referring to the same invoice.
// NB: Posted invoices are NEVER updated.
else // if invoice exists
{
if (gncInvoiceIsPosted (invoice)) // Is it already posted?
{
valid =
gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &iter);
continue; // If already posted then never import
}
if (update != YES) // Pop up a dialog to ask if updates are the expected action
{
dialog = gtk_message_dialog_new (NULL,
GTK_DIALOG_MODAL,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_YES_NO,
"%s",
_("Are you sure you have bills/invoices to update?"));
update = gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
if (update == NO)
{
// Cleanup and leave
g_free (id);
g_free (date_opened);
g_free (owner_id);
g_free (billing_id);
g_free (notes);
g_free (date);
g_free (desc);
g_free (action);
g_free (account);
g_free (quantity);
g_free (price);
g_free (disc_type);
g_free (disc_how);
g_free (discount);
g_free (taxable);
g_free (taxincluded);
g_free (tax_table);
g_free (date_posted);
g_free (due_date);
g_free (account_posted);
g_free (memo_posted);
g_free (accumulatesplits);
return;
}
}
(*n_invoices_updated)++;
}
// add entry to invoice/bill
entry = gncEntryCreate (book);
gncEntryBeginEdit(entry);
currency = gncInvoiceGetCurrency(invoice);
if (currency) denom = gnc_commodity_get_fraction(currency);
// FIXME: Must check for the return value of qof_scan_date!
qof_scan_date (date, &day, &month, &year);
{
GDate *date = g_date_new_dmy(day, month, year);
gncEntrySetDateGDate (entry, date);
g_date_free (date);
}
timespecFromTime64 (&today, gnc_time (NULL)); // set today to the current date
gncEntrySetDateEntered (entry, today);
// Remove escaped quotes
desc = un_escape(desc);
notes = un_escape(notes);
gncEntrySetDescription (entry, desc);
gncEntrySetAction (entry, action);
value = gnc_numeric_zero();
gnc_exp_parser_parse (quantity, &value, NULL);
// Need to set the denom appropriately else we get stupid rounding errors.
value = gnc_numeric_convert (value, denom * 100, GNC_HOW_RND_NEVER);
//DEBUG("qty = %s",gnc_num_dbg_to_string(value));
gncEntrySetQuantity (entry, value);
acc = gnc_account_lookup_for_register (gnc_get_current_root_account (),
account);
if (g_ascii_strcasecmp (type, "BILL") == 0)
{
gncEntrySetBillAccount (entry, acc);
value = gnc_numeric_zero();
gnc_exp_parser_parse (price, &value, NULL);
value = gnc_numeric_convert (value, denom * 100, GNC_HOW_RND_NEVER);
gncEntrySetBillPrice (entry, value);
gncEntrySetBillTaxable (entry, text2bool (taxable));
gncEntrySetBillTaxIncluded (entry, text2bool (taxincluded));
gncEntrySetBillTaxTable (entry, gncTaxTableLookupByName (book, tax_table));
gncEntryCommitEdit(entry);
gncBillAddEntry (invoice, entry);
}
else if (g_ascii_strcasecmp (type, "INVOICE") == 0)
{
gncEntrySetNotes (entry, notes);
gncEntrySetInvAccount (entry, acc);
value = gnc_numeric_zero();
gnc_exp_parser_parse (price, &value, NULL);
value = gnc_numeric_convert (value, denom * 100, GNC_HOW_RND_NEVER);
//DEBUG("price = %s",gnc_num_dbg_to_string(value));
gncEntrySetInvPrice (entry, value);
gncEntrySetInvTaxable (entry, text2bool (taxable));
gncEntrySetInvTaxIncluded (entry, text2bool (taxincluded));
gncEntrySetInvTaxTable (entry, gncTaxTableLookupByName (book, tax_table));
value = gnc_numeric_zero();
gnc_exp_parser_parse (discount, &value, NULL);
value = gnc_numeric_convert (value, denom * 100, GNC_HOW_RND_NEVER);
gncEntrySetInvDiscount (entry, value);
gncEntrySetInvDiscountType (entry, text2disc_type (disc_type));
gncEntrySetInvDiscountHow (entry, text2disc_how (disc_how));
gncEntryCommitEdit(entry);
gncInvoiceAddEntry (invoice, entry);
}
valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &iter);
// handle auto posting of invoices
new_id = NULL;
if (valid)
gtk_tree_model_get (GTK_TREE_MODEL (store), &iter, ID, &new_id, -1);
if (g_strcmp0 (id, new_id) != 0)
{
// the next invoice id is different => try to autopost this invoice
if (qof_scan_date (date_posted, &day, &month, &year))
{
// autopost this invoice
gboolean auto_pay;
Timespec d1, d2;
if (g_ascii_strcasecmp (type, "INVOICE") == 0)
auto_pay = gnc_prefs_get_bool (GNC_PREFS_GROUP_INVOICE, GNC_PREF_AUTO_PAY);
else
auto_pay = gnc_prefs_get_bool (GNC_PREFS_GROUP_BILL, GNC_PREF_AUTO_PAY);
d1 = gnc_dmy2timespec (day, month, year);
// FIXME: Must check for the return value of qof_scan_date!
qof_scan_date (due_date, &day, &month, &year); // obtains the due date, or leaves it at date_posted
d2 = gnc_dmy2timespec (day, month, year);
acc = gnc_account_lookup_for_register
(gnc_get_current_root_account (), account_posted);
gncInvoicePostToAccount (invoice, acc, &d1, &d2,
memo_posted,
text2bool (accumulatesplits),
auto_pay);
DEBUG("Invoice %s posted",id);
}
}
}
// cleanup
g_free (new_id);
g_free (id);
g_free (date_opened);
g_free (owner_id);
g_free (billing_id);
g_free (notes);
g_free (date);
g_free (desc);
g_free (action);
g_free (account);
g_free (quantity);
g_free (price);
g_free (disc_type);
g_free (disc_how);
g_free (discount);
g_free (taxable);
g_free (taxincluded);
g_free (tax_table);
g_free (date_posted);
g_free (due_date);
g_free (account_posted);
g_free (memo_posted);
g_free (accumulatesplits);
}
/* Callback function for combo style custom lists */
static void
combo_selected (GtkComboBox *combo, GreeterItemInfo *item)
{
char *id = NULL;
char *file;
char *active;
if (ve_string_empty (item->id))
return;
active = gtk_combo_box_get_active_text (combo);
if (strcmp (item->id, "session") == 0)
{
combo_session_selected (active);
}
else if (strcmp (item->id, "language") == 0)
{
/*
* Since combo boxes can't store the ID value, have to do some
* extra work to figure out which row is selected.
*/
GtkListStore *lang_model = mdm_lang_get_model ();
GtkTreeIter iter;
char *name, *untranslated, *lang_display_name, *locale_name;
gboolean valid;
valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (lang_model),
&iter);
while (valid)
{
gtk_tree_model_get (GTK_TREE_MODEL (lang_model), &iter,
TRANSLATED_NAME_COLUMN, &name,
UNTRANSLATED_NAME_COLUMN, &untranslated,
LOCALE_COLUMN, &locale_name, -1);
if (untranslated)
lang_display_name = g_strdup_printf ("%s (%s)", name, untranslated);
else
lang_display_name = g_strdup (name);
if (strcmp (lang_display_name, active) == 0)
{
mdm_lang_set_restart_dialog (locale_name);
break;
}
g_free (lang_display_name);
valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (lang_model), &iter);
}
}
else
{
if (DOING_MDM_DEVELOPMENT)
return;
id = gtk_combo_box_get_active_text (combo);
file = g_strdup_printf ("%s/%s.GreeterInfo",
ve_sure_string (mdm_config_get_string (MDM_KEY_SERV_AUTHDIR)),
ve_sure_string (g_getenv ("DISPLAY")));
mdm_save_customlist_data (file, item->id, id);
}
}
void
ip4_routes_dialog_update_setting (GtkWidget *dialog, NMSettingIP4Config *s_ip4)
{
GtkBuilder *builder;
GtkWidget *widget;
GtkTreeModel *model;
GtkTreeIter tree_iter;
gboolean iter_valid;
g_return_if_fail (dialog != NULL);
g_return_if_fail (s_ip4 != NULL);
builder = g_object_get_data (G_OBJECT (dialog), "builder");
g_return_if_fail (builder != NULL);
g_return_if_fail (GTK_IS_BUILDER (builder));
widget = GTK_WIDGET (gtk_builder_get_object (builder, "ip4_routes"));
model = gtk_tree_view_get_model (GTK_TREE_VIEW (widget));
iter_valid = gtk_tree_model_get_iter_first (model, &tree_iter);
nm_setting_ip4_config_clear_routes (s_ip4);
while (iter_valid) {
guint32 addr = 0, prefix = 0, next_hop = 0, metric = 0;
NMIP4Route *route;
/* Address */
if (!get_one_addr (model, &tree_iter, COL_ADDRESS, TRUE, &addr)) {
g_warning ("%s: IPv4 address missing or invalid!", __func__);
goto next;
}
/* Prefix */
if (!get_one_prefix (model, &tree_iter, COL_PREFIX, TRUE, &prefix)) {
g_warning ("%s: IPv4 prefix/netmask missing or invalid!", __func__);
goto next;
}
/* Next hop (optional) */
if (!get_one_addr (model, &tree_iter, COL_NEXT_HOP, FALSE, &next_hop)) {
g_warning ("%s: IPv4 next hop invalid!", __func__);
goto next;
}
/* Metric (optional) */
if (!get_one_int (model, &tree_iter, COL_METRIC, G_MAXUINT32, FALSE, &metric)) {
g_warning ("%s: IPv4 metric invalid!", __func__);
goto next;
}
route = nm_ip4_route_new ();
nm_ip4_route_set_dest (route, addr);
nm_ip4_route_set_prefix (route, prefix);
nm_ip4_route_set_next_hop (route, next_hop);
nm_ip4_route_set_metric (route, metric);
nm_setting_ip4_config_add_route (s_ip4, route);
nm_ip4_route_unref (route);
next:
iter_valid = gtk_tree_model_iter_next (model, &tree_iter);
}
widget = GTK_WIDGET (gtk_builder_get_object (builder, "ip4_ignore_auto_routes"));
g_object_set (s_ip4, NM_SETTING_IP4_CONFIG_IGNORE_AUTO_ROUTES,
gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)),
NULL);
widget = GTK_WIDGET (gtk_builder_get_object (builder, "ip4_never_default"));
g_object_set (s_ip4, NM_SETTING_IP4_CONFIG_NEVER_DEFAULT,
gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)),
NULL);
}
/*
* This function sets the custom list when the session list has changed in
* the session dialog (launched from session button or F10 menu).
*/
void
greeter_custom_set_session (gchar *session)
{
GList *tmp;
int i=0;
/*
* Since the sessions are created before the session list is generated,
* keep track of the session and set active row when it is setup. This
* function will get a NULL when the session is initialized to NULL
* at startup, so just return.
*/
if (session == NULL)
return;
else
{
/*
* If the session_widget hasn't been setup yet (which it won't be when
* the greeter_sessioninit function is called, then just store the
* session and we'll set the value when the combo box is initialized later.
*/
g_free (session_key);
session_key = g_strdup (session);
}
/* Do nothing if there is no session widget */
if (session_widget == NULL)
return;
/* Last isn't in the session list, so handle separate. */
if (strcmp (session, LAST_SESSION) == 0)
{
if (GTK_IS_COMBO_BOX (session_widget))
{
gtk_combo_box_set_active (GTK_COMBO_BOX (session_widget), 0);
}
else if (GTK_IS_SCROLLED_WINDOW (session_widget) &&
GTK_IS_TREE_VIEW (GTK_BIN (session_widget)->child))
{
GtkTreeView *tv = GTK_TREE_VIEW (GTK_BIN (session_widget)->child);
GtkTreeModel *tm = gtk_tree_view_get_model (tv);
GtkTreeSelection *selection = gtk_tree_view_get_selection (tv);
GtkTreeIter loopiter;
if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (tm), &loopiter))
gtk_tree_selection_select_iter (selection, &loopiter);
}
}
/*
* Handle for either combo box or list style, depending on which is being
* used.
. */
if (GTK_IS_COMBO_BOX (session_widget))
{
for (tmp = sessions; tmp != NULL; tmp = tmp->next)
{
char *file;
i++;
file = tmp->data;
if (strcmp (session, file) == 0)
{
gtk_combo_box_set_active (GTK_COMBO_BOX (session_widget), i);
break;
}
}
}
else if (GTK_IS_SCROLLED_WINDOW (session_widget) &&
GTK_IS_TREE_VIEW (GTK_BIN (session_widget)->child))
{
GtkTreeView *tv = GTK_TREE_VIEW (GTK_BIN (session_widget)->child);
GtkTreeModel *tm = gtk_tree_view_get_model (tv);
GtkTreeSelection *selection = gtk_tree_view_get_selection (tv);
GtkTreeIter loopiter;
if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (tm), &loopiter))
{
do
{
char *file;
gtk_tree_model_get (GTK_TREE_MODEL (tm), &loopiter, GREETER_LIST_ID, &file, -1);
if (file != NULL && strcmp (session, file) == 0)
{
GtkTreePath *path = gtk_tree_model_get_path (tm, &loopiter);
gtk_tree_selection_select_iter (selection, &loopiter);
gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (tv),
path, NULL,
FALSE, 0.0, 0.0);
gtk_tree_path_free (path);
break;
}
} while (gtk_tree_model_iter_next (GTK_TREE_MODEL (tm), &loopiter));
}
}
}
static void
update_enabled_disabled_cardinality (BrowserData *data)
{
GtkTreeModel *tree_model;
GtkTreeIter iter;
GtkTreeRowReference *enabled_iter = NULL;
GtkTreeRowReference *disabled_iter = NULL;
GtkTreePath *path;
if (! data->enabled_disabled_cardinality_changed)
return;
tree_model = GTK_TREE_MODEL (GET_WIDGET ("category_liststore"));
if (gtk_tree_model_get_iter_first (tree_model, &iter)) {
do {
char *category_id;
gtk_tree_model_get (tree_model,
&iter,
CATEGORY_ID_COLUMN, &category_id,
-1);
if (g_strcmp0 (category_id, EXTENSION_CATEGORY_ENABLED) == 0) {
path = gtk_tree_model_get_path (tree_model, &iter);
enabled_iter = gtk_tree_row_reference_new (tree_model, path);
gtk_tree_path_free (path);
}
if (g_strcmp0 (category_id, EXTENSION_CATEGORY_DISABLED) == 0) {
path = gtk_tree_model_get_path (tree_model, &iter);
disabled_iter = gtk_tree_row_reference_new (tree_model, path);
gtk_tree_path_free (path);
}
g_free (category_id);
}
while (gtk_tree_model_iter_next (tree_model, &iter));
}
path = gtk_tree_row_reference_get_path (enabled_iter);
if (path != NULL) {
if (gtk_tree_model_get_iter (tree_model, &iter, path)) {
char *s;
s = g_strdup_printf (CARDINALITY_FORMAT, get_category_cardinality (data, EXTENSION_CATEGORY_ENABLED));
gtk_list_store_set (GTK_LIST_STORE (tree_model),
&iter,
CATEGORY_CARDINALITY_COLUMN, s,
-1);
g_free (s);
}
gtk_tree_path_free (path);
}
path = gtk_tree_row_reference_get_path (disabled_iter);
if (path != NULL) {
if (gtk_tree_model_get_iter (tree_model, &iter, path)) {
char *s;
s = g_strdup_printf (CARDINALITY_FORMAT, get_category_cardinality (data, EXTENSION_CATEGORY_DISABLED));
gtk_list_store_set (GTK_LIST_STORE (tree_model),
&iter,
CATEGORY_CARDINALITY_COLUMN, s,
-1);
g_free (s);
}
gtk_tree_path_free (path);
}
gtk_tree_row_reference_free (enabled_iter);
gtk_tree_row_reference_free (disabled_iter);
data->enabled_disabled_cardinality_changed = FALSE;
}
static void
update_timezone (CcDateTimePanel *self)
{
CcDateTimePanelPrivate *priv = self->priv;
GtkWidget *widget;
gchar **split;
GtkTreeIter iter;
GtkTreeModel *model;
/* tz.c updates the local timezone, which means the spin buttons can be
* updated with the current time of the new location */
split = g_strsplit (priv->current_location->zone, "/", 2);
/* remove underscores */
g_strdelimit (split[1], "_", ' ');
/* update region combo */
widget = (GtkWidget *) gtk_builder_get_object (priv->builder,
"region_combobox");
model = gtk_combo_box_get_model (GTK_COMBO_BOX (widget));
gtk_tree_model_get_iter_first (model, &iter);
do
{
gchar *string;
gtk_tree_model_get (model, &iter, CITY_COL_CITY, &string, -1);
if (!g_strcmp0 (string, split[0]))
{
g_free (string);
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (widget), &iter);
break;
}
g_free (string);
}
while (gtk_tree_model_iter_next (model, &iter));
/* update city combo */
widget = (GtkWidget *) gtk_builder_get_object (priv->builder,
"city_combobox");
model = gtk_combo_box_get_model (GTK_COMBO_BOX (widget));
gtk_tree_model_filter_refilter ((GtkTreeModelFilter *) gtk_builder_get_object (priv->builder, "city-modelfilter"));
gtk_tree_model_get_iter_first (model, &iter);
do
{
gchar *string;
gtk_tree_model_get (model, &iter, CITY_COL_CITY, &string, -1);
if (!g_strcmp0 (string, split[1]))
{
g_free (string);
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (widget), &iter);
break;
}
g_free (string);
}
while (gtk_tree_model_iter_next (model, &iter));
g_strfreev (split);
}
