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