static void _fr_process_start (ExecuteData *exec_data) { FrProcess *process = exec_data->process; _g_string_list_free (exec_data->first_error_stdout); exec_data->first_error_stdout = NULL; _g_string_list_free (exec_data->first_error_stderr); exec_data->first_error_stderr = NULL; fr_error_free (exec_data->error); exec_data->error = NULL; fr_channel_data_reset (&process->out); fr_channel_data_reset (&process->err); process->priv->sticky_only = FALSE; process->priv->current_command = 0; process->priv->stopping = FALSE; if (process->priv->n_comm == -1) { process->priv->running = FALSE; _fr_process_execute_complete_in_idle (exec_data); } else { process->priv->running = TRUE; execute_current_command (exec_data); } }
static void query_ready_cb (void *buffer, gsize count, GError *error, gpointer user_data) { FetchData *data = user_data; GList *list; if (error != NULL) { fetch_data_free (data); return; } list = make_file_list_from_search_result (buffer, count, 1); if (list != NULL) { GFile *file; file = g_file_new_for_uri ((char *) list->data); g_load_file_async (file, G_PRIORITY_DEFAULT, NULL, image_data_ready_for_query_cb, data); g_object_unref (file); } else fetch_data_free (data); _g_string_list_free (list); }
void gth_tags_file_free (GthTagsFile *tags) { _g_string_list_free (tags->items); g_strfreev (tags->tags); g_free (tags); }
static void account_manager_dialog_response_cb (GtkDialog *dialog, int response_id, gpointer user_data) { DialogData *data = user_data; switch (response_id) { case GTK_RESPONSE_DELETE_EVENT: case GTK_RESPONSE_CANCEL: gtk_widget_destroy (GTK_WIDGET (dialog)); break; case GTK_RESPONSE_OK: _g_string_list_free (data->accounts); data->accounts = picasa_account_manager_dialog_get_accounts (PICASA_ACCOUNT_MANAGER_DIALOG (dialog)); if (! g_list_find_custom (data->accounts, data->email, (GCompareFunc) strcmp)) { g_free (data->email); data->email = NULL; auto_select_account (data); } else update_account_list (data); picasa_web_accounts_save_to_file (data->accounts, data->email); gtk_widget_destroy (GTK_WIDGET (dialog)); break; default: break; } }
/* called when the main dialog is closed. */ static void destroy_cb (GtkWidget *widget, DialogData *data) { _g_string_list_free (data->selected_files); g_object_unref (G_OBJECT (data->builder)); g_free (data); }
static void execute_data_free (ExecuteData *exec_data) { if (exec_data == NULL) return; if (exec_data->cancel_id != 0) g_cancellable_disconnect (exec_data->cancellable, exec_data->cancel_id); _g_object_unref (exec_data->process); _g_object_unref (exec_data->cancellable); _g_object_unref (exec_data->result); fr_error_free (exec_data->error); fr_error_free (exec_data->first_error); _g_string_list_free (exec_data->first_error_stdout); _g_string_list_free (exec_data->first_error_stderr); g_free (exec_data); }
static void post_photos_data_free (PostPhotosData *post_photos) { if (post_photos == NULL) return; _g_string_list_free (post_photos->ids); _g_object_unref (post_photos->cancellable); _g_object_list_unref (post_photos->file_list); g_free (post_photos); }
void activate_action_view_or_open (GtkAction *action, gpointer data) { FrWindow *window = data; GList *file_list; file_list = fr_window_get_file_list_selection (window, FALSE, NULL); if (file_list == NULL) return; fr_window_open_files (window, file_list, FALSE); _g_string_list_free (file_list); }
/* called when the main dialog is closed. */ static void file_selector_destroy_cb (GtkWidget *widget, DialogData *data) { if (! data->extract_clicked) fr_window_batch_stop (data->window); g_object_unref (data->builder); _g_string_list_free (data->selected_files); g_free (data->base_dir_for_selection); g_object_unref (data->settings); g_free (data); }
void open_with_cb (GtkWidget *widget, void *callback_data) { FrWindow *window = callback_data; GList *file_list; file_list = fr_window_get_file_list_selection (window, FALSE, NULL); if (file_list == NULL) return; fr_window_open_files (window, file_list, TRUE); _g_string_list_free (file_list); }
static void gth_file_source_finalize (GObject *object) { GthFileSource *file_source = GTH_FILE_SOURCE (object); if (file_source->priv != NULL) { gth_file_source_clear_queue (file_source); _g_string_list_free (file_source->priv->schemes); _g_object_unref (file_source->priv->cancellable); g_free (file_source->priv); file_source->priv = NULL; } G_OBJECT_CLASS (parent_class)->finalize (object); }
/* called when the dialog is dismissed. */ static void response_cb (GtkWidget *widget, int response_id, DialogData *data) { gboolean selected_files; gboolean pattern_files; FrWindow *window = data->window; GList *file_list = NULL; gboolean do_not_remove_if_null = FALSE; switch (response_id) { case GTK_RESPONSE_OK: selected_files = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (data->d_selected_files_radio)); pattern_files = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (data->d_files_radio)); /* create the file list. */ if (selected_files) { file_list = data->selected_files; data->selected_files = NULL; /* do not free the list when destroying the dialog. */ } else if (pattern_files) { const char *pattern; pattern = gtk_entry_get_text (GTK_ENTRY (data->d_files_entry)); file_list = fr_window_get_file_list_pattern (window, pattern); if (file_list == NULL) do_not_remove_if_null = TRUE; } /* remove ! */ if (! do_not_remove_if_null || (file_list != NULL)) fr_window_archive_remove (window, file_list); _g_string_list_free (file_list); break; } /* close the dialog. */ gtk_widget_destroy (data->dialog); }
static void destroy_dialog (DialogData *data) { if (data->dialog != NULL) gtk_widget_destroy (data->dialog); if (data->service != NULL) gth_task_completed (GTH_TASK (data->service), NULL); _g_object_unref (data->cancellable); _g_string_list_free (data->photos_ids); _g_object_unref (data->photoset); _g_object_list_unref (data->photosets); _g_object_unref (data->service); gtk_widget_destroy (data->progress_dialog); _g_object_unref (data->builder); _g_object_list_unref (data->file_list); _g_object_unref (data->location); g_object_unref (data->settings); g_free (data); }
static void destroy_cb (GtkWidget *widget, DialogData *data) { if (data->searching) { data->destroy = TRUE; g_cancellable_cancel (data->cancellable); return; } g_signal_handlers_disconnect_by_data (data->icon_view, data); g_object_unref (data->cancellable); _g_string_list_free (data->file_list); _g_object_unref (data->cover_backup); g_object_unref (data->builder); g_free (data->album); g_free (data->artist); g_free (data); }
gboolean gth_tags_file_load_from_data (GthTagsFile *tags, const char *data, gsize length, GError **error) { DomDocument *doc; gboolean success; _g_string_list_free (tags->items); tags->items = NULL; doc = dom_document_new (); success = dom_document_load (doc, data, length, error); if (success) { DomElement *tags_node; DomElement *child; tags_node = DOM_ELEMENT (doc)->first_child; if ((tags_node != NULL) && (g_strcmp0 (tags_node->tag_name, "tags") == 0)) { for (child = tags_node->first_child; child != NULL; child = child->next_sibling) { if (strcmp (child->tag_name, "tag") == 0) { const char *tag_value; tag_value = dom_element_get_attribute (child, "value"); if (tag_value != NULL) tags->items = g_list_prepend (tags->items, g_strdup (tag_value)); } } tags->items = g_list_reverse (tags->items); } } g_object_unref (doc); return success; }
static void destroy_dialog (DialogData *data) { if (data->dialog != NULL) gtk_widget_destroy (data->dialog); data->dialog = NULL; gth_browser_set_dialog (data->browser, "rename_series", NULL); if (data->update_id != 0) { g_source_remove (data->update_id); data->update_id = 0; } g_free (data->required_attributes); g_object_unref (data->builder); _g_object_list_unref (data->file_data_list); _g_object_list_unref (data->file_list); _g_string_list_free (data->new_names_list); g_list_free (data->new_file_list); g_object_unref (data->settings); g_free (data); }
static void destroy_dialog (DialogData *data) { if (data->dialog != NULL) gtk_widget_destroy (data->dialog); if (data->conn != NULL) gth_task_completed (GTH_TASK (data->conn), NULL); _g_object_unref (data->cancellable); _g_object_unref (data->album); _g_object_unref (data->picasaweb); _g_object_unref (data->conn); _g_object_list_unref (data->albums); g_free (data->challange); g_free (data->password); g_free (data->email); _g_object_unref (data->user); _g_string_list_free (data->accounts); _g_object_unref (data->builder); _g_object_list_unref (data->file_list); _g_object_unref (data->location); g_free (data); }
static gint check_child (gpointer data) { ExecuteData *exec_data = data; FrProcess *process = exec_data->process; FrCommandInfo *info; pid_t pid; int status; gboolean continue_process; info = g_ptr_array_index (process->priv->comm, process->priv->current_command); /* Remove check. */ g_source_remove (process->priv->check_timeout); process->priv->check_timeout = 0; if (fr_channel_data_read (&process->out) == G_IO_STATUS_ERROR) { exec_data->error = fr_error_new (FR_ERROR_IO_CHANNEL, 0, process->out.error); } else if (fr_channel_data_read (&process->err) == G_IO_STATUS_ERROR) { exec_data->error = fr_error_new (FR_ERROR_IO_CHANNEL, 0, process->err.error); } else { pid = waitpid (process->priv->command_pid, &status, WNOHANG); if (pid != process->priv->command_pid) { /* Add check again. */ process->priv->check_timeout = g_timeout_add (REFRESH_RATE, check_child, exec_data); return FALSE; } } if (info->ignore_error && (exec_data->error != NULL)) { #ifdef DEBUG { GList *scan; g_print ("** ERROR **\n"); g_print ("%s\n", exec_data->error->gerror->message); for (scan = process->err.raw; scan; scan = scan->next) g_print ("%s\n", (char *)scan->data); } #endif fr_clear_error (&exec_data->error); debug (DEBUG_INFO, "[error ignored]\n"); } else if (exec_data->error == NULL) { if (WIFEXITED (status)) { if (WEXITSTATUS (status) == 255) { exec_data->error = fr_error_new (FR_ERROR_COMMAND_NOT_FOUND, 0, NULL); } else if (WEXITSTATUS (status) != 0) { exec_data->error = fr_error_new (FR_ERROR_COMMAND_ERROR, WEXITSTATUS (status), NULL); } } else { exec_data->error = fr_error_new (FR_ERROR_EXITED_ABNORMALLY, 255, NULL); } } process->priv->command_pid = 0; if (exec_data->error == NULL) { if (fr_channel_data_flush (&process->out) == G_IO_STATUS_ERROR) exec_data->error = fr_error_new (FR_ERROR_IO_CHANNEL, 0, process->out.error); else if (fr_channel_data_flush (&process->err) == G_IO_STATUS_ERROR) exec_data->error = fr_error_new (FR_ERROR_IO_CHANNEL, 0, process->err.error); } if (info->end_func != NULL) (*info->end_func) (info->end_data); /**/ if ((exec_data->error != NULL) && (exec_data->error->type == FR_ERROR_IO_CHANNEL) && g_error_matches (exec_data->error->gerror, G_CONVERT_ERROR, G_CONVERT_ERROR_ILLEGAL_SEQUENCE)) { if (process->priv->current_charset < n_charsets - 1) { /* try with another charset */ process->priv->current_charset++; _fr_process_restart (exec_data); return FALSE; } fr_error_free (exec_data->error); exec_data->error = fr_error_new (FR_ERROR_BAD_CHARSET, 0, exec_data->error->gerror); } /* Check whether to continue or stop the process */ continue_process = TRUE; if (info->continue_func != NULL) continue_process = (*info->continue_func) (&exec_data->error, info->continue_data); /* Execute the next command. */ if (continue_process) { if (exec_data->error != NULL) { allow_sticky_processes_only (exec_data); #ifdef DEBUG { GList *scan; g_print ("** ERROR **\n"); for (scan = process->err.raw; scan; scan = scan->next) g_print ("%s\n", (char *)scan->data); } #endif } if (process->priv->sticky_only) { do { process->priv->current_command++; } while ((process->priv->current_command <= process->priv->n_comm) && ! command_is_sticky (process, process->priv->current_command)); } else process->priv->current_command++; if (process->priv->current_command <= process->priv->n_comm) { execute_current_command (exec_data); return FALSE; } } /* Done */ process->priv->current_command = -1; process->priv->use_standard_locale = FALSE; if (process->out.raw != NULL) process->out.raw = g_list_reverse (process->out.raw); if (process->err.raw != NULL) process->err.raw = g_list_reverse (process->err.raw); process->priv->running = FALSE; process->priv->stopping = FALSE; if (process->priv->sticky_only) { /* Restore the first error. */ fr_error_free (exec_data->error); exec_data->error = fr_error_copy (exec_data->first_error); /* Restore the first error output as well. */ _g_string_list_free (process->out.raw); process->out.raw = exec_data->first_error_stdout; exec_data->first_error_stdout = NULL; _g_string_list_free (process->err.raw); process->err.raw = exec_data->first_error_stderr; exec_data->first_error_stderr = NULL; } _fr_process_execute_complete_in_idle (exec_data); return FALSE; }
static void fr_command_jar_add (FrCommand *comm, const char *from_file, GList *file_list, const char *base_dir, gboolean update, gboolean follow_links) { FrProcess *proc = comm->process; GList *zip_list = NULL, *jardata_list = NULL, *jar_list = NULL; GList *scan; char *tmp_dir; for (scan = file_list; scan; scan = scan->next) { char *filename = scan->data; char *path = g_build_filename (base_dir, filename, NULL); char *package = NULL; if (_g_filename_has_extension (filename, ".java")) package = get_package_name_from_java_file (path); else if (_g_filename_has_extension (filename, ".class")) package = get_package_name_from_class_file (path); if ((package == NULL) || (strlen (package) == 0)) zip_list = g_list_append (zip_list, g_strdup (filename)); else { JarData *newdata = g_new0 (JarData, 1); newdata->package_minus_one_level = _g_path_remove_level (package); newdata->link_name = g_strdup (_g_path_get_basename (package)); newdata->rel_path = _g_path_remove_level (filename); newdata->filename = g_strdup (_g_path_get_basename (filename)); jardata_list = g_list_append (jardata_list, newdata); } g_free (package); g_free (path); } tmp_dir = _g_path_get_temp_work_dir (NULL); for (scan = jardata_list; scan ; scan = scan->next) { JarData *jdata = scan->data; char *pack_path; GFile *directory; char *old_link; char *link_name; int retval; pack_path = g_build_filename (tmp_dir, jdata->package_minus_one_level, NULL); directory = g_file_new_for_path (pack_path); if (! _g_file_make_directory_tree (directory, 0755, NULL)) { g_object_unref (directory); g_free (pack_path); continue; } old_link = g_build_filename (base_dir, jdata->rel_path, NULL); link_name = g_build_filename (pack_path, jdata->link_name, NULL); retval = symlink (old_link, link_name); if ((retval != -1) || (errno == EEXIST)) jar_list = g_list_append (jar_list, g_build_filename (jdata->package_minus_one_level, jdata->link_name, jdata->filename, NULL)); g_free (link_name); g_free (old_link); g_object_unref (directory); g_free (pack_path); } if (zip_list != NULL) FR_COMMAND_CLASS (fr_command_jar_parent_class)->add (comm, NULL, zip_list, base_dir, update, follow_links); if (jar_list != NULL) FR_COMMAND_CLASS (fr_command_jar_parent_class)->add (comm, NULL, jar_list, tmp_dir, update, follow_links); fr_process_begin_command (proc, "rm"); fr_process_set_working_dir (proc, "/"); fr_process_add_arg (proc, "-r"); fr_process_add_arg (proc, "-f"); fr_process_add_arg (proc, tmp_dir); fr_process_end_command (proc); fr_process_set_sticky (proc, TRUE); for (scan = jardata_list; scan ; scan = scan->next) { JarData *jdata = scan->data; g_free (jdata->filename); g_free (jdata->package_minus_one_level); g_free (jdata->link_name); g_free (jdata->rel_path); } _g_string_list_free (jardata_list); _g_string_list_free (jar_list); _g_string_list_free (zip_list); g_free (tmp_dir); }
static void copy_to_folder_dialog (GthBrowser *browser, GList *files, gboolean move) { GSettings *settings; GtkWidget *dialog; char *start_uri; GList *history; GList *scan; GtkWidget *box; GtkWidget *view_destination_button; settings = g_settings_new (GTHUMB_FILE_MANAGER_SCHEMA); dialog = gtk_file_chooser_dialog_new (move ? _("Move To") : _("Copy To"), GTK_WINDOW (browser), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, _GTK_LABEL_CANCEL, GTK_RESPONSE_CANCEL, (move ? _("Move") : _("Copy")), GTK_RESPONSE_ACCEPT, NULL); _gtk_dialog_add_class_to_response (GTK_DIALOG (dialog), GTK_RESPONSE_ACCEPT, GTK_STYLE_CLASS_SUGGESTED_ACTION); start_uri = g_settings_get_string (settings, PREF_FILE_MANAGER_COPY_LAST_FOLDER); if ((start_uri == NULL) || (strcmp (start_uri, "") == 0)) { g_free (start_uri); start_uri = g_strdup (get_home_uri ()); } gtk_file_chooser_set_uri (GTK_FILE_CHOOSER (dialog), start_uri); g_free(start_uri); history = _g_settings_get_string_list (settings, PREF_FILE_MANAGER_COPY_HISTORY); for (scan = history; scan; scan = scan->next) { char *uri = scan->data; gtk_file_chooser_add_shortcut_folder_uri (GTK_FILE_CHOOSER (dialog), uri, NULL); } box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_container_set_border_width (GTK_CONTAINER (box), 6); gtk_widget_show (box); view_destination_button = gtk_check_button_new_with_mnemonic (_("_View the destination")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (view_destination_button), g_settings_get_boolean (settings, PREF_FILE_MANAGER_COPY_VIEW_DESTINATION)); gtk_widget_show (view_destination_button); gtk_box_pack_start (GTK_BOX (box), view_destination_button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), box, FALSE, FALSE, 0); if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT) { char *destination_uri; destination_uri = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (dialog)); if (destination_uri != NULL) { gboolean view_destination; /* save the options */ view_destination = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (view_destination_button)); g_settings_set_boolean (settings, PREF_FILE_MANAGER_COPY_VIEW_DESTINATION, view_destination); g_settings_set_string (settings, PREF_FILE_MANAGER_COPY_LAST_FOLDER, destination_uri); /* save the destination in the history list, prevent * the list from growing without limit. */ history = g_list_prepend (history, g_strdup (destination_uri)); while (g_list_length (history) > MAX_HISTORY_LENGTH) { GList *link = g_list_last (history); history = g_list_remove_link (history, link); _g_string_list_free (link); } _g_settings_set_string_list (settings, PREF_FILE_MANAGER_COPY_HISTORY, history); /* copy / move the files */ copy_files_to_folder (browser, files, move, destination_uri, view_destination); } g_free (destination_uri); } _g_string_list_free (history); gtk_widget_destroy (dialog); g_object_unref (settings); }
static void dlg_photo_importer (GthBrowser *browser, GFile *source, DlgImporterSourceType selector_type) { DialogData *data; GtkCellRenderer *renderer; GthFileDataSort *sort_type; GList *tests, *scan; char *general_filter; int i, active_filter; int i_general; if (gth_browser_get_dialog (browser, "photo_importer") != NULL) { gtk_window_present (GTK_WINDOW (gth_browser_get_dialog (browser, "photo_importer"))); return; } data = g_new0 (DialogData, 1); data->browser = browser; data->builder = gtk_builder_new_from_resource ("/org/gnome/gThumb/photo_importer/data/ui/photo-importer.ui"); data->settings = g_settings_new (GTHUMB_PHOTO_IMPORTER_SCHEMA); data->selector_type = selector_type; data->source = _g_object_ref (source); data->cancellable = g_cancellable_new (); data->vfs_source = g_object_new (GTH_TYPE_FILE_SOURCE_VFS, NULL); gth_file_source_monitor_entry_points (GTH_FILE_SOURCE (data->vfs_source)); /* Get the widgets. */ data->dialog = _gtk_builder_get_widget (data->builder, "photo_importer_dialog"); _gtk_window_resize_to_fit_screen_height (data->dialog, 580); gth_browser_set_dialog (browser, "photo_importer", data->dialog); g_object_set_data (G_OBJECT (data->dialog), "dialog_data", data); if (data->selector_type == DLG_IMPORTER_SOURCE_TYPE_DEVICE) { gtk_window_set_title (GTK_WINDOW (data->dialog), _("Import from Removable Device")); data->device_list_store = gtk_list_store_new (SOURCE_LIST_COLUMNS, G_TYPE_OBJECT, G_TYPE_ICON, G_TYPE_STRING); data->device_chooser = gtk_combo_box_new_with_model (GTK_TREE_MODEL (data->device_list_store)); gtk_widget_show (data->device_chooser); gtk_box_pack_start (GTK_BOX (GET_WIDGET ("source_box")), data->device_chooser, TRUE, TRUE, 0); gtk_label_set_mnemonic_widget (GTK_LABEL (GET_WIDGET ("source_label")), data->device_chooser); renderer = gtk_cell_renderer_pixbuf_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (data->device_chooser), renderer, FALSE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (data->device_chooser), renderer, "gicon", SOURCE_LIST_COLUMN_ICON, NULL); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (data->device_chooser), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (data->device_chooser), renderer, "text", SOURCE_LIST_COLUMN_NAME, NULL); g_object_unref (data->device_list_store); } else { if (data->source == NULL) { if (GTH_IS_FILE_SOURCE_VFS (gth_browser_get_location_source (browser))) data->source = _g_object_ref (gth_browser_get_location (browser)); if (data->source == NULL) data->source = g_file_new_for_uri (get_home_uri ()); } gtk_window_set_title (GTK_WINDOW (data->dialog), _("Import from Folder")); data->folder_chooser = gtk_file_chooser_button_new (_("Choose a folder"), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER); gtk_label_set_mnemonic_widget (GTK_LABEL (GET_WIDGET ("source_label")), data->folder_chooser); gtk_file_chooser_set_file (GTK_FILE_CHOOSER (data->folder_chooser), data->source, NULL); gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (data->folder_chooser), FALSE); gtk_widget_show (data->folder_chooser); gtk_box_pack_start (GTK_BOX (GET_WIDGET ("source_box")), data->folder_chooser, TRUE, TRUE, 0); } data->file_list = gth_file_list_new (gth_grid_view_new (), GTH_FILE_LIST_MODE_NORMAL, FALSE); sort_type = gth_main_get_sort_type ("file::mtime"); gth_file_list_set_sort_func (GTH_FILE_LIST (data->file_list), sort_type->cmp_func, FALSE); gth_file_list_enable_thumbs (GTH_FILE_LIST (data->file_list), TRUE); gth_file_list_set_ignore_hidden (GTH_FILE_LIST (data->file_list), TRUE); gth_file_list_set_thumb_size (GTH_FILE_LIST (data->file_list), 128); gth_file_list_set_caption (GTH_FILE_LIST (data->file_list), "standard::display-name,gth::file::display-size"); gtk_widget_show (data->file_list); gtk_box_pack_start (GTK_BOX (GET_WIDGET ("filelist_box")), data->file_list, TRUE, TRUE, 0); tests = gth_main_get_registered_objects_id (GTH_TYPE_TEST); general_filter = "file::type::is_media"; /* default value */ active_filter = 0; data->filter_combobox = gtk_combo_box_text_new (); for (i = 0, i_general = -1, scan = tests; scan; scan = scan->next, i++) { const char *registered_test_id = scan->data; GthTest *test; if (strncmp (registered_test_id, "file::type::", 12) != 0) continue; i_general += 1; test = gth_main_get_registered_object (GTH_TYPE_TEST, registered_test_id); if (strcmp (registered_test_id, general_filter) == 0) { active_filter = i_general; gth_file_list_set_filter (GTH_FILE_LIST (data->file_list), test); } data->general_tests = g_list_prepend (data->general_tests, g_strdup (gth_test_get_id (test))); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (data->filter_combobox), gth_test_get_display_name (test)); g_object_unref (test); } data->general_tests = g_list_reverse (data->general_tests); gtk_combo_box_set_active (GTK_COMBO_BOX (data->filter_combobox), active_filter); gtk_widget_show (data->filter_combobox); gtk_container_add (GTK_CONTAINER (GET_WIDGET ("filter_box")), data->filter_combobox); gtk_label_set_mnemonic_widget (GTK_LABEL (GET_WIDGET ("filter_label")), data->filter_combobox); gtk_label_set_use_underline (GTK_LABEL (GET_WIDGET ("filter_label")), TRUE); _g_string_list_free (tests); data->tags_entry = gth_tags_entry_new (GTH_TAGS_ENTRY_MODE_POPUP); gtk_widget_show (data->tags_entry); gtk_box_pack_start (GTK_BOX (GET_WIDGET ("tags_entry_box")), data->tags_entry, TRUE, TRUE, 0); gtk_label_set_mnemonic_widget (GTK_LABEL (GET_WIDGET ("tags_label")), data->tags_entry); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("delete_checkbutton")), g_settings_get_boolean (data->settings, PREF_PHOTO_IMPORTER_DELETE_FROM_DEVICE)); data->preferences_dialog = gth_import_preferences_dialog_new (); gtk_window_set_transient_for (GTK_WINDOW (data->preferences_dialog), GTK_WINDOW (data->dialog)); gtk_box_pack_start (GTK_BOX (GET_WIDGET ("destination_button_box")), gth_import_destination_button_new (GTH_IMPORT_PREFERENCES_DIALOG (data->preferences_dialog)), TRUE, TRUE, 0); gtk_widget_show_all (GET_WIDGET ("destination_button_box")); /* Set the signals handlers. */ g_signal_connect (G_OBJECT (data->dialog), "delete-event", G_CALLBACK (dialog_delete_event_cb), data); g_signal_connect (GET_WIDGET ("ok_button"), "clicked", G_CALLBACK (ok_clicked_cb), data); g_signal_connect (GET_WIDGET ("cancel_button"), "clicked", G_CALLBACK (close_dialog), data); if (data->selector_type == DLG_IMPORTER_SOURCE_TYPE_DEVICE) g_signal_connect (data->device_chooser, "changed", G_CALLBACK (device_chooser_changed_cb), data); else g_signal_connect (data->folder_chooser, "selection-changed", G_CALLBACK (folder_chooser_file_set_cb), data); g_signal_connect (data->filter_combobox, "changed", G_CALLBACK (filter_combobox_changed_cb), data); g_signal_connect (gth_file_view_get_model (GTH_FILE_VIEW (gth_file_list_get_view (GTH_FILE_LIST (data->file_list)))), "visibility_changed", G_CALLBACK (file_store_changed_cb), data); g_signal_connect (gth_file_list_get_view (GTH_FILE_LIST (data->file_list)), "file-selection-changed", G_CALLBACK (file_view_selection_changed_cb), data); data->entry_points_changed_id = g_signal_connect (gth_main_get_default_monitor (), "entry-points-changed", G_CALLBACK (entry_points_changed_cb), data); g_signal_connect_after (GET_WIDGET ("event_entry"), "changed", G_CALLBACK (event_entry_changed_cb), data); /* Run dialog. */ gtk_window_set_transient_for (GTK_WINDOW (data->dialog), GTK_WINDOW (browser)); gtk_window_set_modal (GTK_WINDOW (data->dialog), FALSE); gtk_widget_show (data->dialog); gth_import_preferences_dialog_set_event (GTH_IMPORT_PREFERENCES_DIALOG (data->preferences_dialog), gtk_entry_get_text (GTK_ENTRY (GET_WIDGET ("event_entry")))); if (data->selector_type == DLG_IMPORTER_SOURCE_TYPE_DEVICE) update_device_source_list (data); else load_file_list (data); }
static void destroy_dialog (gpointer user_data) { DialogData *data = user_data; gboolean delete_imported; g_signal_handler_disconnect (gth_main_get_default_monitor (), data->entry_points_changed_id); delete_imported = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("delete_checkbutton"))); g_settings_set_boolean (data->settings, PREF_PHOTO_IMPORTER_DELETE_FROM_DEVICE, delete_imported); if (data->import) { GSettings *importer_settings; GFile *destination; gboolean single_subfolder; GthSubfolderType subfolder_type; GthSubfolderFormat subfolder_format; char *custom_format; GList *file_list; importer_settings = g_settings_new (GTHUMB_IMPORTER_SCHEMA); destination = gth_import_preferences_get_destination (); single_subfolder = g_settings_get_boolean (importer_settings, PREF_IMPORTER_SUBFOLDER_SINGLE); subfolder_type = g_settings_get_enum (importer_settings, PREF_IMPORTER_SUBFOLDER_TYPE); subfolder_format = g_settings_get_enum (importer_settings, PREF_IMPORTER_SUBFOLDER_FORMAT); custom_format = g_settings_get_string (importer_settings, PREF_IMPORTER_SUBFOLDER_CUSTOM_FORMAT); file_list = get_selected_file_list (data); if (file_list != NULL) { char **tags; GthTask *task; tags = gth_tags_entry_get_tags (GTH_TAGS_ENTRY (data->tags_entry), TRUE); task = gth_import_task_new (data->browser, file_list, destination, subfolder_type, subfolder_format, single_subfolder, custom_format, gtk_entry_get_text (GTK_ENTRY (GET_WIDGET ("event_entry"))), tags, delete_imported, FALSE, g_settings_get_boolean (data->settings, PREF_PHOTO_IMPORTER_ADJUST_ORIENTATION)); gth_browser_exec_task (data->browser, task, FALSE); g_strfreev (tags); g_object_unref (task); } _g_object_list_unref (file_list); g_free (custom_format); _g_object_unref (destination); g_object_unref (importer_settings); } gtk_widget_destroy (data->dialog); gth_browser_set_dialog (data->browser, "photo_importer", NULL); g_object_unref (data->vfs_source); g_object_unref (data->settings); g_object_unref (data->builder); _g_object_unref (data->source); _g_object_unref (data->last_source); _g_object_unref (data->cancellable); _g_object_list_unref (data->files); _g_string_list_free (data->general_tests); if (! data->import && gth_browser_get_close_with_task (data->browser)) gth_window_close (GTH_WINDOW (data->browser)); g_free (data); }
static int extract_cb (GtkWidget *w, DialogData *data) { FrWindow *window = data->window; gboolean do_not_extract = FALSE; GFile *destination; gboolean skip_newer; gboolean selected_files; gboolean pattern_files; gboolean junk_paths; GList *file_list; char *base_dir = NULL; GError *error = NULL; data->extract_clicked = TRUE; /* collect extraction options. */ destination = gtk_file_chooser_get_file (GTK_FILE_CHOOSER (data->dialog)); /* check directory existence. */ if (! _g_file_query_is_dir (destination)) { if (! ForceDirectoryCreation) { GtkWidget *d; int r; char *folder_name; char *msg; folder_name = _g_file_get_display_basename (destination); msg = g_strdup_printf (_("Destination folder \"%s\" does not exist.\n\nDo you want to create it?"), folder_name); g_free (folder_name); d = _gtk_message_dialog_new (GTK_WINDOW (data->dialog), GTK_DIALOG_MODAL, msg, NULL, _GTK_LABEL_CANCEL, GTK_RESPONSE_CANCEL, _("Create _Folder"), GTK_RESPONSE_YES, NULL); gtk_dialog_set_default_response (GTK_DIALOG (d), GTK_RESPONSE_YES); r = gtk_dialog_run (GTK_DIALOG (d)); gtk_widget_destroy (GTK_WIDGET (d)); g_free (msg); if (r != GTK_RESPONSE_YES) do_not_extract = TRUE; } if (! do_not_extract && ! _g_file_make_directory_tree (destination, 0755, &error)) { GtkWidget *d; d = _gtk_error_dialog_new (GTK_WINDOW (window), GTK_DIALOG_DESTROY_WITH_PARENT, NULL, _("Extraction not performed"), _("Could not create the destination folder: %s."), error->message); gtk_dialog_run (GTK_DIALOG (d)); gtk_widget_destroy (GTK_WIDGET (d)); g_error_free (error); return FALSE; } } if (do_not_extract) { GtkWidget *d; d = _gtk_message_dialog_new (GTK_WINDOW (window), GTK_DIALOG_DESTROY_WITH_PARENT, _("Extraction not performed"), NULL, _GTK_LABEL_CLOSE, GTK_RESPONSE_OK, NULL); gtk_dialog_set_default_response (GTK_DIALOG (d), GTK_RESPONSE_OK); gtk_dialog_run (GTK_DIALOG (d)); gtk_widget_destroy (GTK_WIDGET (d)); if (fr_window_is_batch_mode (data->window)) gtk_widget_destroy (data->dialog); return FALSE; } /* check extraction directory permissions. */ if (_g_file_query_is_dir (destination) && ! _g_file_check_permissions (destination, R_OK | W_OK)) { GtkWidget *d; char *utf8_path; utf8_path = _g_file_get_display_basename (destination); d = _gtk_error_dialog_new (GTK_WINDOW (window), GTK_DIALOG_DESTROY_WITH_PARENT, NULL, _("Extraction not performed"), _("You don't have the right permissions to extract archives in the folder \"%s\""), utf8_path); gtk_dialog_run (GTK_DIALOG (d)); gtk_widget_destroy (GTK_WIDGET (d)); g_free (utf8_path); g_object_unref (destination); return FALSE; } fr_window_set_extract_default_dir (window, destination); skip_newer = ! gtk_toggle_button_get_inconsistent (GTK_TOGGLE_BUTTON (GET_WIDGET ("keep_newer_checkbutton"))) && gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("keep_newer_checkbutton"))); junk_paths = ! gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("keep_structure_checkbutton"))); if (! gtk_toggle_button_get_inconsistent (GTK_TOGGLE_BUTTON (GET_WIDGET ("keep_newer_checkbutton")))) g_settings_set_boolean (data->settings, PREF_EXTRACT_SKIP_NEWER, skip_newer); g_settings_set_boolean (data->settings, PREF_EXTRACT_RECREATE_FOLDERS, ! junk_paths); selected_files = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("selected_files_radiobutton"))); pattern_files = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("file_pattern_radiobutton"))); /* create the file list. */ file_list = NULL; if (selected_files) { file_list = data->selected_files; data->selected_files = NULL; /* do not the list when destroying the dialog. */ } else if (pattern_files) { const char *pattern; pattern = gtk_entry_get_text (GTK_ENTRY (GET_WIDGET ("file_pattern_entry"))); file_list = fr_window_get_file_list_pattern (window, pattern); if (file_list == NULL) { gtk_widget_destroy (data->dialog); g_object_unref (destination); return FALSE; } } if (selected_files) { base_dir = data->base_dir_for_selection; data->base_dir_for_selection = NULL; } else base_dir = NULL; /* close the dialog. */ gtk_widget_destroy (data->dialog); /* extract ! */ fr_window_extract_archive_and_continue (window, file_list, destination, base_dir, skip_newer, FR_OVERWRITE_ASK, junk_paths); _g_string_list_free (file_list); g_object_unref (destination); g_free (base_dir); return TRUE; }
void ss__gth_catalog_read_from_doc (GthCatalog *catalog, DomElement *root) { DomElement *node; for (node = root->first_child; node; node = node->next_sibling) { DomElement *child; if (g_strcmp0 (node->tag_name, "slideshow") != 0) continue; g_value_hash_set_boolean (catalog->attributes, "slideshow::personalize", g_strcmp0 (dom_element_get_attribute (node, "personalize"), "true") == 0); g_value_hash_set_boolean (catalog->attributes, "slideshow::automatic", g_strcmp0 (dom_element_get_attribute (node, "automatic"), "true") == 0); g_value_hash_set_boolean (catalog->attributes, "slideshow::wrap-around", g_strcmp0 (dom_element_get_attribute (node, "wrap-around"), "true") == 0); g_value_hash_set_boolean (catalog->attributes, "slideshow::random-order", g_strcmp0 (dom_element_get_attribute (node, "random-order"), "true") == 0); for (child = node->first_child; child; child = child->next_sibling) { if (g_strcmp0 (child->tag_name, "delay") == 0) { int delay; sscanf (dom_element_get_inner_text (child), "%d", &delay); g_value_hash_set_int (catalog->attributes, "slideshow::delay", delay); } else if (g_strcmp0 (child->tag_name, "transition") == 0) { g_value_hash_set_string (catalog->attributes, "slideshow::transition", dom_element_get_inner_text (child)); } else if (g_strcmp0 (child->tag_name, "playlist") == 0) { DomElement *file; GList *audio_files; audio_files = NULL; for (file = child->first_child; file; file = file->next_sibling) { if (g_strcmp0 (file->tag_name, "file") == 0) audio_files = g_list_prepend (audio_files, g_strdup (dom_element_get_attribute (file, "uri"))); } audio_files = g_list_reverse (audio_files); if (audio_files != NULL) { char **audio_files_v; audio_files_v = _g_string_list_to_strv (audio_files); g_value_hash_set_stringv (catalog->attributes, "slideshow::playlist", audio_files_v); g_strfreev (audio_files_v); } else g_value_hash_unset (catalog->attributes, "slideshow::playlist"); _g_string_list_free (audio_files); } } } }