/** * 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); }