static void
gth_file_tool_negative_activate (GthFileTool *base)
{
GtkWidget *window;
GtkWidget *viewer_page;
GthTask *task;
window = gth_file_tool_get_window (base);
viewer_page = gth_browser_get_viewer_page (GTH_BROWSER (window));
if (! GTH_IS_IMAGE_VIEWER_PAGE (viewer_page))
return;
task = gth_image_viewer_task_new (GTH_IMAGE_VIEWER_PAGE (viewer_page),
_("Applying changes"),
NULL,
negative_exec,
NULL,
NULL,
NULL);
g_signal_connect (task,
"completed",
G_CALLBACK (gth_image_viewer_task_set_destination),
NULL);
gth_browser_exec_task (GTH_BROWSER (window), task, FALSE);
}
static void
edit_metadata_dialog__response_cb (GtkDialog *dialog,
int response,
gpointer user_data)
{
DialogData *data = user_data;
GthMonitor *monitor;
GHashTable *parents;
GList *scan;
GthTask *task;
if ((response != GTK_RESPONSE_OK) && (response != GTK_RESPONSE_APPLY)) {
cancel_file_list_loading (data);
close_dialog (data);
return;
}
if (data->file_list == NULL)
return;
data->close_dialog = (response == GTK_RESPONSE_OK);
/* get the parents list */
parents = g_hash_table_new_full (g_file_hash, (GEqualFunc) g_file_equal, g_object_unref, NULL);
for (scan = data->file_list; scan; scan = scan->next) {
GthFileData *file_data = scan->data;
GFile *parent;
parent = g_file_get_parent (file_data->file);
if (G_LIKELY (parent != NULL)) {
if (g_hash_table_lookup (parents, parent) == NULL)
g_hash_table_insert (parents, g_object_ref (parent), GINT_TO_POINTER (1));
g_object_unref (parent);
}
}
_g_object_list_unref (data->parents);
data->parents = g_hash_table_get_keys (parents);
g_list_foreach (data->parents, (GFunc) g_object_ref, NULL);
g_hash_table_unref (parents);
/* ignore changes to all the parents */
monitor = gth_main_get_default_monitor ();
for (scan = data->parents; scan; scan = scan->next)
gth_monitor_pause (monitor, (GFile *) scan->data);
gth_edit_metadata_dialog_update_info (GTH_EDIT_METADATA_DIALOG (data->dialog), data->file_list);
dialog_data_ref (data);
task = gth_save_file_data_task_new (data->file_list, "*");
g_signal_connect (task,
"completed",
G_CALLBACK (saver_completed_cb),
data);
gth_browser_exec_task (data->browser, task, FALSE);
g_object_unref (task);
}
static void
gth_file_tool_equalize_activate (GthFileTool *base)
{
GtkWidget *window;
GtkWidget *viewer_page;
EqualizeData *equalize_data;
GthTask *task;
window = gth_file_tool_get_window (base);
viewer_page = gth_browser_get_viewer_page (GTH_BROWSER (window));
if (! GTH_IS_IMAGE_VIEWER_PAGE (viewer_page))
return;
equalize_data = g_new0 (EqualizeData, 1);
task = gth_image_viewer_task_new (GTH_IMAGE_VIEWER_PAGE (viewer_page),
_("Equalizing image histogram"),
NULL,
equalize_exec,
NULL,
equalize_data,
equalize_destroy_data);
g_signal_connect (task,
"completed",
G_CALLBACK (gth_image_viewer_task_set_destination),
NULL);
gth_browser_exec_task (GTH_BROWSER (window), task, FALSE);
}
static gboolean
update_file_list (gpointer user_data)
{
DialogData *data = user_data;
LoaderData *loader_data;
GList *items;
GList *file_data_list;
if (data->update_selectection_event != 0) {
g_source_remove (data->update_selectection_event);
data->update_selectection_event = 0;
}
cancel_file_list_loading (data);
loader_data = g_new0 (LoaderData, 1);
loader_data->data = dialog_data_ref (data);
items = gth_file_selection_get_selected (GTH_FILE_SELECTION (gth_browser_get_file_list_view (data->browser)));
file_data_list = gth_file_list_get_files (GTH_FILE_LIST (gth_browser_get_file_list (data->browser)), items);
loader_data->files = gth_file_data_list_to_file_list (file_data_list);
data->loader = gth_load_file_data_task_new (loader_data->files, "*");
g_signal_connect (data->loader,
"completed",
G_CALLBACK (loader_completed_cb),
loader_data);
gth_browser_exec_task (data->browser, data->loader, FALSE);
_g_object_list_unref (file_data_list);
_gtk_tree_path_list_free (items);
return FALSE;
}
static gboolean
update_image_size_cb (gpointer user_data)
{
GthFileToolResize *self = user_data;
self->priv->update_size_id = 0;
if (self->priv->resize_task != NULL) {
gth_task_cancel (self->priv->resize_task);
return FALSE;
}
self->priv->resize_task = gth_image_task_new (_("Resizing images"),
NULL,
resize_task_exec,
NULL,
self,
NULL);
if (self->priv->apply_to_original)
gth_image_task_set_source_surface (GTH_IMAGE_TASK (self->priv->resize_task), gth_image_viewer_page_tool_get_source (GTH_IMAGE_VIEWER_PAGE_TOOL (self)));
else
gth_image_task_set_source_surface (GTH_IMAGE_TASK (self->priv->resize_task), self->priv->preview);
g_signal_connect (self->priv->resize_task,
"completed",
G_CALLBACK (resize_task_completed_cb),
self);
gth_browser_exec_task (GTH_BROWSER (gth_file_tool_get_window (GTH_FILE_TOOL (self))),
self->priv->resize_task,
GTH_TASK_FLAGS_DEFAULT);
return FALSE;
}
static void
ok_button_clicked_cb (GtkButton *button,
GthFileToolSharpen *self)
{
GtkWidget *window;
GtkWidget *viewer_page;
SharpenData *sharpen_data;
GthTask *task;
if (self->priv->apply_event != 0) {
g_source_remove (self->priv->apply_event);
self->priv->apply_event = 0;
}
window = gth_file_tool_get_window (GTH_FILE_TOOL (self));
viewer_page = gth_browser_get_viewer_page (GTH_BROWSER (window));
if (! GTH_IS_IMAGE_VIEWER_PAGE (viewer_page))
return;
sharpen_data = sharpen_data_new (self);
sharpen_data->viewer_page = g_object_ref (viewer_page);
sharpen_data->source = cairo_surface_reference (self->priv->source);
task = gth_async_task_new (sharpen_before,
sharpen_exec,
sharpen_after,
sharpen_data,
sharpen_data_free);
gth_browser_exec_task (GTH_BROWSER (gth_file_tool_get_window (GTH_FILE_TOOL (self))), task, FALSE);
g_object_unref (task);
gth_file_tool_hide_options (GTH_FILE_TOOL (self));
}
static void
copy_files_to_folder (GthBrowser *browser,
GList *files,
gboolean move,
char *destination_uri,
gboolean view_destination)
{
GthFileData *destination_data;
GthFileSource *file_source;
CopyToFolderData *data;
GthTask *task;
destination_data = gth_file_data_new_for_uri (destination_uri, NULL);
file_source = gth_main_get_file_source (destination_data->file);
data = g_new0 (CopyToFolderData, 1);
data->browser = g_object_ref (browser);
data->move = move;
data->destination = g_file_dup (destination_data->file);
data->view_destination = view_destination;
task = gth_copy_task_new (file_source, destination_data, move, files, -1);
g_signal_connect (task,
"completed",
G_CALLBACK (copy_complete_cb),
data);
gth_browser_exec_task (browser, task, GTH_TASK_FLAGS_DEFAULT);
g_object_unref (file_source);
}
static gboolean
apply_cb (gpointer user_data)
{
GthFileToolAdjustContrast *self = user_data;
GtkWidget *window;
if (self->priv->apply_event != 0) {
g_source_remove (self->priv->apply_event);
self->priv->apply_event = 0;
}
if (self->priv->image_task != NULL) {
gth_task_cancel (self->priv->image_task);
return FALSE;
}
window = gth_file_tool_get_window (GTH_FILE_TOOL (self));
self->priv->image_task = get_image_task_for_method (self->priv->method);
if (self->priv->apply_to_original)
gth_image_task_set_source_surface (GTH_IMAGE_TASK (self->priv->image_task), gth_image_viewer_page_tool_get_source (GTH_IMAGE_VIEWER_PAGE_TOOL (self)));
else
gth_image_task_set_source_surface (GTH_IMAGE_TASK (self->priv->image_task), self->priv->preview);
g_signal_connect (self->priv->image_task,
"completed",
G_CALLBACK (image_task_completed_cb),
self);
gth_browser_exec_task (GTH_BROWSER (window), self->priv->image_task, GTH_TASK_FLAGS_DEFAULT);
return FALSE;
}
static void
gth_file_tool_negative_activate (GthFileTool *base)
{
GtkWidget *window;
GtkWidget *viewer_page;
GtkWidget *viewer;
cairo_surface_t *image;
NegativeData *negative_data;
GthTask *task;
window = gth_file_tool_get_window (base);
viewer_page = gth_browser_get_viewer_page (GTH_BROWSER (window));
if (! GTH_IS_IMAGE_VIEWER_PAGE (viewer_page))
return;
viewer = gth_image_viewer_page_get_image_viewer (GTH_IMAGE_VIEWER_PAGE (viewer_page));
image = gth_image_viewer_get_current_image (GTH_IMAGE_VIEWER (viewer));
if (image == NULL)
return;
negative_data = g_new0 (NegativeData, 1);
negative_data->viewer_page = viewer_page;
negative_data->source = cairo_surface_reference (image);
task = gth_async_task_new (negative_init,
negative_exec,
negative_after,
negative_data,
negative_data_free);
gth_browser_exec_task (GTH_BROWSER (window), task, FALSE);
g_object_unref (task);
}
static void
ok_clicked_cb (GtkWidget *widget,
DialogData *data)
{
ResizeData *resize_data;
GtkTreeIter iter;
char *mime_type;
GthTask *resize_task;
GthTask *list_task;
resize_data = g_new0 (ResizeData, 1);
resize_data->width = gtk_spin_button_get_value (GTK_SPIN_BUTTON (GET_WIDGET ("width_spinbutton")));
resize_data->height = gtk_spin_button_get_value (GTK_SPIN_BUTTON (GET_WIDGET ("height_spinbutton")));
resize_data->unit = units[gtk_combo_box_get_active (GTK_COMBO_BOX (GET_WIDGET ("unit_combobox")))];
resize_data->keep_aspect_ratio = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("keep_ratio_checkbutton")));
resize_data->allow_swap = FALSE;
gtk_combo_box_get_active_iter (GTK_COMBO_BOX (GET_WIDGET ("mime_type_combobox")), &iter);
gtk_tree_model_get (GTK_TREE_MODEL (GET_WIDGET ("mime_type_liststore")), &iter,
MIME_TYPE_COLUMN_TYPE, &mime_type,
-1);
g_settings_set_int (data->settings, PREF_RESIZE_IMAGES_SERIES_WIDTH, resize_data->width);
g_settings_set_int (data->settings, PREF_RESIZE_IMAGES_SERIES_HEIGHT, resize_data->height);
g_settings_set_enum (data->settings, PREF_RESIZE_IMAGES_UNIT, resize_data->unit);
g_settings_set_boolean (data->settings, PREF_RESIZE_IMAGES_KEEP_RATIO, resize_data->keep_aspect_ratio);
g_settings_set_string (data->settings, PREF_RESIZE_IMAGES_MIME_TYPE, mime_type ? mime_type : "");
resize_task = gth_image_task_new (_("Resizing images"),
NULL,
exec_resize,
NULL,
resize_data,
g_free);
list_task = gth_image_list_task_new (data->browser,
data->file_list,
GTH_IMAGE_TASK (resize_task));
gth_image_list_task_set_overwrite_mode (GTH_IMAGE_LIST_TASK (list_task), GTH_OVERWRITE_ASK);
gth_image_list_task_set_output_mime_type (GTH_IMAGE_LIST_TASK (list_task), mime_type);
if (data->use_destination) {
GFile *destination;
destination = gtk_file_chooser_get_file (GTK_FILE_CHOOSER (GET_WIDGET ("destination_filechooserbutton")));
gth_image_list_task_set_destination (GTH_IMAGE_LIST_TASK (list_task), destination);
g_object_unref (destination);
}
gth_browser_exec_task (data->browser, list_task, FALSE);
g_object_unref (list_task);
g_object_unref (resize_task);
g_free (mime_type);
gtk_widget_destroy (data->dialog);
}
void
fm__gth_browser_folder_tree_drag_data_received_cb (GthBrowser *browser,
GthFileData *destination,
GList *file_list,
GdkDragAction action)
{
GthFileSource *file_source;
GthTask *task;
if (destination == NULL)
return;
file_source = gth_main_get_file_source (destination->file);
if (file_source == NULL)
return;
if ((action == GDK_ACTION_MOVE) && ! gth_file_source_can_cut (file_source, (GFile *) file_list->data)) {
GtkWidget *dialog;
int response;
dialog = _gtk_message_dialog_new (GTK_WINDOW (browser),
GTK_DIALOG_MODAL,
GTK_STOCK_DIALOG_QUESTION,
_("Could not move the files"),
_("Files cannot be moved to the current location, as alternative you can choose to copy them."),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_COPY, GTK_RESPONSE_OK,
NULL);
response = gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
if (response == GTK_RESPONSE_CANCEL)
return;
action = GDK_ACTION_COPY;
}
task = gth_copy_task_new (file_source,
destination,
(action == GDK_ACTION_MOVE),
file_list,
-1);
gth_browser_exec_task (browser, task, FALSE);
g_object_unref (task);
g_object_unref (file_source);
}
static void
save_as_response_cb (GtkDialog *file_sel,
int response,
SaveData *save_data)
{
GFile *file;
const char *mime_type;
GFile *folder;
char *folder_uri;
GthTask *task;
if (response != GTK_RESPONSE_OK) {
GthMediaViewerPage *page = save_data->page;
if (save_data->playing_before_screenshot)
gst_element_set_state (gth_media_viewer_page_get_playbin (page), GST_STATE_PLAYING);
save_date_free (save_data);
gtk_widget_destroy (GTK_WIDGET (file_sel));
return;
}
if (! gth_file_chooser_dialog_get_file (GTH_FILE_CHOOSER_DIALOG (file_sel), &file, &mime_type))
return;
folder = g_file_get_parent (file);
folder_uri = g_file_get_uri (folder);
g_settings_set_string (save_data->settings, PREF_GSTREAMER_TOOLS_SCREESHOT_LOCATION, folder_uri);
save_data->file_data = gth_file_data_new (file, NULL);
gth_file_data_set_mime_type (save_data->file_data, mime_type);
task = gth_save_image_task_new (save_data->image,
mime_type,
save_data->file_data,
GTH_OVERWRITE_RESPONSE_YES);
g_signal_connect (task,
"completed",
G_CALLBACK (save_screenshot_task_completed_cb),
save_data);
gth_browser_exec_task (GTH_BROWSER (save_data->browser), task, FALSE);
gtk_widget_destroy (GTK_WIDGET (file_sel));
g_free (folder_uri);
g_object_unref (folder);
g_object_unref (file);
}
static gboolean
apply_cb (gpointer user_data)
{
GthFileToolGrayscale *self = user_data;
GtkWidget *window;
GrayscaleData *grayscale_data;
if (self->priv->apply_event != 0) {
g_source_remove (self->priv->apply_event);
self->priv->apply_event = 0;
}
if (self->priv->image_task != NULL) {
gth_task_cancel (self->priv->image_task);
return FALSE;
}
window = gth_file_tool_get_window (GTH_FILE_TOOL (self));
grayscale_data = g_new0 (GrayscaleData, 1);
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("brightness_radiobutton"))))
grayscale_data->method = METHOD_BRIGHTNESS;
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("saturation_radiobutton"))))
grayscale_data->method = METHOD_SATURATION;
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("average_radiobutton"))))
grayscale_data->method = METHOD_AVARAGE;
self->priv->image_task = gth_image_task_new (_("Applying changes"),
NULL,
grayscale_exec,
NULL,
grayscale_data,
grayscale_data_free);
if (self->priv->apply_to_original)
gth_image_task_set_source_surface (GTH_IMAGE_TASK (self->priv->image_task), gth_image_viewer_page_tool_get_source (GTH_IMAGE_VIEWER_PAGE_TOOL (self)));
else
gth_image_task_set_source_surface (GTH_IMAGE_TASK (self->priv->image_task), self->priv->preview);
g_signal_connect (self->priv->image_task,
"completed",
G_CALLBACK (image_task_completed_cb),
self);
gth_browser_exec_task (GTH_BROWSER (window), self->priv->image_task, FALSE);
return FALSE;
}
void
gth_browser_activate_duplicate (GSimpleAction *action,
GVariant *parameter,
gpointer user_data)
{
GthBrowser *browser = GTH_BROWSER (user_data);
GList *items;
GList *file_list;
GthTask *task;
items = gth_file_selection_get_selected (GTH_FILE_SELECTION (gth_browser_get_file_list_view (browser)));
file_list = gth_file_list_get_files (GTH_FILE_LIST (gth_browser_get_file_list (browser)), items);
task = gth_duplicate_task_new (file_list);
gth_browser_exec_task (browser, task, GTH_TASK_FLAGS_DEFAULT);
g_object_unref (task);
_g_object_list_unref (file_list);
_gtk_tree_path_list_free (items);
}
void
gth_browser_activate_action_tool_reset_orientation (GtkAction *action,
GthBrowser *browser)
{
GList *items;
GList *file_data_list;
GList *file_list;
GthTask *task;
items = gth_file_selection_get_selected (GTH_FILE_SELECTION (gth_browser_get_file_list_view (browser)));
file_data_list = gth_file_list_get_files (GTH_FILE_LIST (gth_browser_get_file_list (browser)), items);
file_list = gth_file_data_list_to_file_list (file_data_list);
task = gth_reset_orientation_task_new (browser, file_list);
gth_browser_exec_task (browser, task, FALSE);
g_object_unref (task);
_g_object_list_unref (file_list);
_g_object_list_unref (file_data_list);
_gtk_tree_path_list_free (items);
}
void
gth_browser_activate_action_tool_import_embedded_metadata (GtkAction *action,
GthBrowser *browser)
{
GList *items;
GList *file_data_list;
GthTask *task;
items = gth_file_selection_get_selected (GTH_FILE_SELECTION (gth_browser_get_file_list_view (browser)));
file_data_list = gth_file_list_get_files (GTH_FILE_LIST (gth_browser_get_file_list (browser)), items);
/* use all the files if no file or only one file is selected */
if ((file_data_list == NULL) || (file_data_list->next == NULL)) {
_g_object_list_unref (file_data_list);
file_data_list = gth_file_store_get_visibles (gth_browser_get_file_store (browser));
}
task = gth_import_metadata_task_new (browser, file_data_list);
gth_browser_exec_task (browser, task, FALSE);
g_object_unref (task);
_g_object_list_unref (file_data_list);
_gtk_tree_path_list_free (items);
}
static void
gth_file_tool_adjust_contrast_activate (GthFileTool *base)
{
GtkWidget *window;
GtkWidget *viewer_page;
GtkWidget *viewer;
cairo_surface_t *image;
AdjustContrastData *adjust_contrast_data;
GthTask *task;
window = gth_file_tool_get_window (base);
viewer_page = gth_browser_get_viewer_page (GTH_BROWSER (window));
if (! GTH_IS_IMAGE_VIEWER_PAGE (viewer_page))
return;
viewer = gth_image_viewer_page_get_image_viewer (GTH_IMAGE_VIEWER_PAGE (viewer_page));
image = gth_image_viewer_get_current_image (GTH_IMAGE_VIEWER (viewer));
if (image == NULL)
return;
adjust_contrast_data = g_new0 (AdjustContrastData, 1);
adjust_contrast_data->viewer_page = g_object_ref (viewer_page);
adjust_contrast_data->source = cairo_surface_reference (image);
adjust_contrast_data->lowest = NULL;
adjust_contrast_data->highest = NULL;
adjust_contrast_data->factor = NULL;
task = gth_image_task_new (_("Applying changes"),
NULL,
adjust_contrast_exec,
adjust_contrast_after,
adjust_contrast_data,
adjust_contrast_data_free);
g_signal_connect (task,
"completed",
G_CALLBACK (image_task_completed_cb),
base);
gth_browser_exec_task (GTH_BROWSER (window), task, FALSE);
}
static void
gth_image_viewer_page_tool_activate (GthFileTool *base)
{
GthImageViewerPageTool *self = (GthImageViewerPageTool *) base;
GtkWidget *window;
GthViewerPage *viewer_page;
/* load the original image */
window = gth_file_tool_get_window (GTH_FILE_TOOL (self));
viewer_page = gth_browser_get_viewer_page (GTH_BROWSER (window));
if (! GTH_IS_IMAGE_VIEWER_PAGE (viewer_page))
return;
self->priv->image_task = gth_original_image_task_new (GTH_IMAGE_VIEWER_PAGE (viewer_page));
g_signal_connect (self->priv->image_task,
"completed",
G_CALLBACK (original_image_task_completed_cb),
self);
gth_browser_exec_task (GTH_BROWSER (gth_file_tool_get_window (GTH_FILE_TOOL (self))),
self->priv->image_task,
GTH_TASK_FLAGS_DEFAULT);
}
void
gth_browser_activate_action_tool_desktop_background (GtkAction *action,
GthBrowser *browser)
{
WallpaperData *wdata;
gboolean saving_wallpaper = FALSE;
GList *items;
GList *file_list;
GthFileData *file_data;
const char *mime_type;
wdata = wallpaper_data_new (browser);
items = gth_file_selection_get_selected (GTH_FILE_SELECTION (gth_browser_get_file_list_view (browser)));
file_list = gth_file_list_get_files (GTH_FILE_LIST (gth_browser_get_file_list (browser)), items);
file_data = (file_list != NULL) ? file_list->data : NULL;
mime_type = (file_data != NULL) ? gth_file_data_get_mime_type (file_data) : NULL;
if (gth_main_extension_is_active ("image_viewer")
&& (gth_browser_get_file_modified (browser) || ! _gdk_pixbuf_mime_type_is_readable (mime_type)))
{
GtkWidget *viewer_page;
viewer_page = gth_browser_get_viewer_page (browser);
if (viewer_page != NULL) {
GthImage *image;
GthTask *task;
image = gth_image_new_for_surface (gth_image_viewer_page_get_image (GTH_IMAGE_VIEWER_PAGE (viewer_page)));
file_data = gth_file_data_new (wdata->new_style.file, NULL);
task = gth_save_image_task_new (image,
"image/jpeg",
file_data,
GTH_OVERWRITE_RESPONSE_YES);
g_signal_connect (task,
"completed",
G_CALLBACK (save_wallpaper_task_completed_cb),
wdata);
gth_browser_exec_task (GTH_BROWSER (browser), task, FALSE);
saving_wallpaper = TRUE;
_g_object_unref (task);
g_object_unref (image);
}
}
if (saving_wallpaper)
return;
if (file_data == NULL)
return;
if (g_file_is_native (file_data->file)) {
_g_object_unref (wdata->new_style.file);
wdata->new_style.file = g_file_dup (file_data->file);
wallpaper_data_set (wdata);
}
else
g_file_copy_async (file_data->file,
wdata->new_style.file,
G_FILE_COPY_OVERWRITE,
G_PRIORITY_DEFAULT,
NULL,
NULL,
NULL,
copy_wallpaper_ready_cb,
wdata);
_g_object_list_unref (file_list);
_gtk_tree_path_list_free (items);
}
static void
gth_file_list_drag_data_received (GtkWidget *file_view,
GdkDragContext *context,
int x,
int y,
GtkSelectionData *selection_data,
guint info,
guint time,
gpointer user_data)
{
GthBrowser *browser = user_data;
gboolean success = FALSE;
char **uris;
GList *selected_files;
GdkDragAction action;
g_signal_stop_emission_by_name (file_view, "drag-data-received");
action = gdk_drag_context_get_suggested_action (context);
if (action == GDK_ACTION_COPY || action == GDK_ACTION_MOVE) {
success = TRUE;
}
if (action == GDK_ACTION_ASK) {
GdkDragAction actions =
_gtk_menu_ask_drag_drop_action (file_view,
gdk_drag_context_get_actions (context),
time);
gdk_drag_status (context, actions, time);
success = gdk_drag_context_get_selected_action (context) != 0;
}
if (gtk_selection_data_get_data_type (selection_data) == XDND_ACTION_DIRECT_SAVE_ATOM) {
const guchar *data;
int format;
int length;
data = gtk_selection_data_get_data (selection_data);
format = gtk_selection_data_get_format (selection_data);
length = gtk_selection_data_get_length (selection_data);
if ((format == 8) && (length == 1) && (data[0] == 'S')) {
success = TRUE;
}
else {
gdk_property_change (gdk_drag_context_get_dest_window (context),
XDND_ACTION_DIRECT_SAVE_ATOM,
TEXT_PLAIN_ATOM,
8,
GDK_PROP_MODE_REPLACE,
(const guchar *) "",
0);
success = FALSE;
}
gtk_drag_finish (context, success, FALSE, time);
return;
}
gtk_drag_finish (context, success, FALSE, time);
if (! success)
return;
uris = gtk_selection_data_get_uris (selection_data);
selected_files = _g_file_list_new_from_uriv (uris);
if (selected_files != NULL) {
if (gtk_drag_get_source_widget (context) == file_view) {
GList *file_data_list;
GList *visible_files;
BrowserData *data;
GthTask *task;
file_data_list = gth_file_store_get_visibles (gth_browser_get_file_store (browser));
visible_files = gth_file_data_list_to_file_list (file_data_list);
data = g_object_get_data (G_OBJECT (browser), BROWSER_DATA_KEY);
task = gth_reorder_task_new (gth_browser_get_location_source (browser),
gth_browser_get_location_data (browser),
visible_files,
selected_files,
data->drop_pos);
gth_browser_exec_task (browser, task, FALSE);
g_object_unref (task);
_g_object_list_unref (visible_files);
_g_object_list_unref (file_data_list);
}
else {
GthFileSource *file_source;
gboolean cancel = FALSE;
gboolean move;
file_source = gth_browser_get_location_source (browser);
move = gdk_drag_context_get_selected_action (context) == GDK_ACTION_MOVE;
if (move && ! gth_file_source_can_cut (file_source, (GFile *) selected_files->data)) {
GtkWidget *dialog;
int response;
dialog = _gtk_message_dialog_new (GTK_WINDOW (browser),
GTK_DIALOG_MODAL,
GTK_STOCK_DIALOG_QUESTION,
_("Could not move the files"),
_("Files cannot be moved to the current location, as alternative you can choose to copy them."),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_COPY, GTK_RESPONSE_OK,
NULL);
response = gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
if (response == GTK_RESPONSE_CANCEL)
cancel = TRUE;
move = FALSE;
}
if (! cancel) {
GthFileSource *location_source;
BrowserData *data;
GthTask *task;
location_source = gth_main_get_file_source (gth_browser_get_location (browser));
data = g_object_get_data (G_OBJECT (browser), BROWSER_DATA_KEY);
task = gth_copy_task_new (location_source,
gth_browser_get_location_data (browser),
move,
selected_files,
data->drop_pos);
gth_browser_exec_task (browser, task, FALSE);
g_object_unref (task);
g_object_unref (location_source);
}
}
}
_g_object_list_unref (selected_files);
g_strfreev (uris);
}
static void
import_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:
gth_file_list_cancel (GTH_FILE_LIST (data->file_list), (DataFunc) gtk_widget_destroy, data->dialog);
break;
case GTK_RESPONSE_OK:
{
GtkTreeIter iter;
FlickrPhotoset *photoset;
GList *file_list;
if (! gtk_combo_box_get_active_iter (GTK_COMBO_BOX (GET_WIDGET ("photoset_combobox")), &iter)) {
gtk_widget_set_sensitive (GET_WIDGET ("download_button"), FALSE);
return;
}
gtk_tree_model_get (GTK_TREE_MODEL (GET_WIDGET ("photoset_liststore")), &iter,
PHOTOSET_DATA_COLUMN, &photoset,
-1);
file_list = get_files_to_download (data);
if (file_list != NULL) {
GSettings *settings;
GFile *destination;
gboolean single_subfolder;
GthSubfolderType subfolder_type;
GthSubfolderFormat subfolder_format;
char *custom_format;
GthTask *task;
settings = g_settings_new (GTHUMB_IMPORTER_SCHEMA);
destination = gth_import_preferences_get_destination ();
subfolder_type = g_settings_get_enum (settings, PREF_IMPORTER_SUBFOLDER_TYPE);
subfolder_format = g_settings_get_enum (settings, PREF_IMPORTER_SUBFOLDER_FORMAT);
single_subfolder = g_settings_get_boolean (settings, PREF_IMPORTER_SUBFOLDER_SINGLE);
custom_format = g_settings_get_string (settings, PREF_IMPORTER_SUBFOLDER_CUSTOM_FORMAT);
task = gth_import_task_new (data->browser,
file_list,
destination,
subfolder_type,
subfolder_format,
single_subfolder,
custom_format,
(photoset->title != NULL ? photoset->title : ""),
NULL,
FALSE,
FALSE,
FALSE);
gth_browser_exec_task (data->browser, task, FALSE);
gtk_widget_destroy (data->dialog);
g_object_unref (task);
_g_object_unref (destination);
g_object_unref (settings);
}
_g_object_list_unref (file_list);
g_object_unref (photoset);
}
break;
default:
break;
}
}
static void
ok_button_clicked (GtkWidget *button,
DialogData *data)
{
GthChangeFields change_fields;
GthChangeType change_type;
GthDateTime *date_time;
int time_adjustment;
GthTask *task;
date_time = NULL;
change_fields = 0;
if (IS_ACTIVE (GET_WIDGET ("change_last_modified_checkbutton")))
change_fields |= GTH_CHANGE_LAST_MODIFIED_DATE;
if (IS_ACTIVE (GET_WIDGET ("change_comment_checkbutton")))
change_fields |= GTH_CHANGE_COMMENT_DATE;
change_type = 0;
time_adjustment = 0;
if (IS_ACTIVE (GET_WIDGET ("to_following_date_radiobutton"))) {
change_type = GTH_CHANGE_TO_FOLLOWING_DATE;
date_time = gth_datetime_new ();
gth_time_selector_get_value (GTH_TIME_SELECTOR (data->date_selector), date_time);
}
else if (IS_ACTIVE (GET_WIDGET ("to_last_modified_date_radiobutton")))
change_type = GTH_CHANGE_TO_FILE_MODIFIED_DATE;
else if (IS_ACTIVE (GET_WIDGET ("to_creation_date_radiobutton")))
change_type = GTH_CHANGE_TO_FILE_CREATION_DATE;
else if (IS_ACTIVE (GET_WIDGET ("to_photo_original_date_radiobutton")))
change_type = GTH_CHANGE_TO_PHOTO_ORIGINAL_DATE;
else if (IS_ACTIVE (GET_WIDGET ("adjust_time_radiobutton"))) {
change_type = GTH_CHANGE_ADJUST_TIME;
time_adjustment = (HOURS_TO_SECONDS (gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (GET_WIDGET ("adjust_time_h_spinbutton"))))
+ MINS_TO_SECONDS (gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (GET_WIDGET ("adjust_time_m_spinbutton"))))
+ gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (GET_WIDGET ("adjust_time_s_spinbutton"))));
if (gtk_combo_box_get_active (GTK_COMBO_BOX (GET_WIDGET ("adjust_sign_combobox"))) == 1)
time_adjustment = -time_adjustment;
}
/* save the preferences */
g_settings_set_boolean (data->settings, PREF_CHANGE_DATE_SET_LAST_MODIFIED_DATE, (change_fields & GTH_CHANGE_LAST_MODIFIED_DATE) == GTH_CHANGE_LAST_MODIFIED_DATE);
g_settings_set_boolean (data->settings, PREF_CHANGE_DATE_SET_COMMENT_DATE, (change_fields & GTH_CHANGE_COMMENT_DATE) == GTH_CHANGE_COMMENT_DATE);
g_settings_set_boolean (data->settings, PREF_CHANGE_DATE_TO_FOLLOWING_DATE, change_type == GTH_CHANGE_TO_FOLLOWING_DATE);
if (change_type == GTH_CHANGE_TO_FOLLOWING_DATE) {
char *s;
s = gth_datetime_to_exif_date (date_time);
g_settings_set_string (data->settings, PREF_CHANGE_DATE_DATE, s);
g_free (s);
}
g_settings_set_boolean (data->settings, PREF_CHANGE_DATE_TO_FILE_MODIFIED_DATE, change_type == GTH_CHANGE_TO_FILE_MODIFIED_DATE);
g_settings_set_boolean (data->settings, PREF_CHANGE_DATE_TO_FILE_CREATION_DATE, change_type == GTH_CHANGE_TO_FILE_CREATION_DATE);
g_settings_set_boolean (data->settings, PREF_CHANGE_DATE_TO_PHOTO_ORIGINAL_DATE, change_type == GTH_CHANGE_TO_PHOTO_ORIGINAL_DATE);
g_settings_set_boolean (data->settings, PREF_CHANGE_DATE_ADJUST_TIME, change_type == GTH_CHANGE_ADJUST_TIME);
if (change_type == GTH_CHANGE_ADJUST_TIME)
g_settings_set_int (data->settings, PREF_CHANGE_DATE_TIME_ADJUSTMENT, time_adjustment);
/* exec the task */
task = gth_change_date_task_new (gth_browser_get_location (data->browser),
data->file_list,
change_fields,
change_type,
date_time,
time_adjustment);
gth_browser_exec_task (data->browser, task, FALSE);
gtk_widget_destroy (data->dialog);
g_object_unref (task);
gth_datetime_free (date_time);
}
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 void
import_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:
gth_file_list_cancel (GTH_FILE_LIST (data->file_list), (DataFunc) gtk_widget_destroy, data->dialog);
break;
case GTK_RESPONSE_OK:
{
GtkTreeIter iter;
PicasaWebAlbum *album;
GList *file_list;
if (! gtk_combo_box_get_active_iter (GTK_COMBO_BOX (GET_WIDGET ("album_combobox")), &iter)) {
gtk_dialog_set_response_sensitive (GTK_DIALOG (data->dialog),
GTK_RESPONSE_OK,
FALSE);
return;
}
gtk_tree_model_get (GTK_TREE_MODEL (GET_WIDGET ("album_liststore")), &iter,
ALBUM_DATA_COLUMN, &album,
-1);
file_list = get_files_to_download (data);
if (file_list != NULL) {
GFile *destination;
GError *error = NULL;
GSettings *settings;
gboolean single_subfolder;
GthSubfolderType subfolder_type;
GthSubfolderFormat subfolder_format;
char *custom_format;
char **tags;
int i;
GthTask *task;
destination = gth_import_preferences_get_destination ();
if (! gth_import_task_check_free_space (destination, file_list, &error)) {
_gtk_error_dialog_from_gerror_show (GTK_WINDOW (data->dialog),
_("Could not import the files"),
error);
g_clear_error (&error);
_g_object_unref (destination);
_g_object_list_unref (file_list);
g_object_unref (album);
return;
}
settings = g_settings_new (GTHUMB_IMPORTER_SCHEMA);
subfolder_type = g_settings_get_enum (settings, PREF_IMPORTER_SUBFOLDER_TYPE);
subfolder_format = g_settings_get_enum (settings, PREF_IMPORTER_SUBFOLDER_FORMAT);
single_subfolder = g_settings_get_boolean (settings, PREF_IMPORTER_SUBFOLDER_SINGLE);
custom_format = g_settings_get_string (settings, PREF_IMPORTER_SUBFOLDER_CUSTOM_FORMAT);
tags = g_strsplit ((album->keywords != NULL ? album->keywords : ""), ",", -1);
for (i = 0; tags[i] != NULL; i++)
tags[i] = g_strstrip (tags[i]);
task = gth_import_task_new (data->browser,
file_list,
destination,
subfolder_type,
subfolder_format,
single_subfolder,
custom_format,
(album->title != NULL ? album->title : ""),
tags,
FALSE,
FALSE,
FALSE);
gth_browser_exec_task (data->browser, task, GTH_TASK_FLAGS_DEFAULT);
gtk_widget_destroy (data->dialog);
g_object_unref (task);
g_strfreev (tags);
g_object_unref (settings);
_g_object_unref (destination);
}
_g_object_list_unref (file_list);
g_object_unref (album);
}
break;
default:
break;
}
}
static void
clipboard_received_cb (GtkClipboard *clipboard,
GtkSelectionData *selection_data,
gpointer user_data)
{
PasteData *paste_data = user_data;
GthBrowser *browser = paste_data->browser;
const char *raw_data;
char **clipboard_data;
int i;
GtkTreePath *path;
int position;
GthTask *task;
raw_data = (const char *) gtk_selection_data_get_data (selection_data);
if (raw_data == NULL) {
paste_data_free (paste_data);
return;
}
clipboard_data = g_strsplit_set (raw_data, "\n\r", -1);
if ((clipboard_data == NULL) || (clipboard_data[0] == NULL)) {
g_strfreev (clipboard_data);
paste_data_free (paste_data);
return;
}
paste_data->cut = strcmp (clipboard_data[0], "cut") == 0;
paste_data->files = NULL;
for (i = 1; clipboard_data[i] != NULL; i++)
if (strcmp (clipboard_data[i], "") != 0)
paste_data->files = g_list_prepend (paste_data->files, g_file_new_for_uri (clipboard_data[i]));
paste_data->files = g_list_reverse (paste_data->files);
paste_data->file_source = gth_main_get_file_source (paste_data->destination->file);
if (paste_data->cut && ! gth_file_source_can_cut (paste_data->file_source, paste_data->files->data)) {
GtkWidget *dialog;
int response;
dialog = _gtk_message_dialog_new (GTK_WINDOW (browser),
GTK_DIALOG_MODAL,
_GTK_ICON_NAME_DIALOG_QUESTION,
_("Could not move the files"),
_("Files cannot be moved to the current location, as alternative you can choose to copy them."),
_GTK_LABEL_CANCEL, GTK_RESPONSE_CANCEL,
_("Copy"), GTK_RESPONSE_OK,
NULL);
response = gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
if (response == GTK_RESPONSE_CANCEL) {
paste_data_free (paste_data);
return;
}
paste_data->cut = FALSE;
}
position = -1;
path = gth_file_selection_get_last_selected (GTH_FILE_SELECTION (gth_browser_get_file_list_view (browser)));
if (path != NULL) {
int *indices;
indices = gtk_tree_path_get_indices (path);
if (indices != NULL)
position = indices[0] + 1;
gtk_tree_path_free (path);
}
task = gth_copy_task_new (paste_data->file_source,
paste_data->destination,
paste_data->cut,
paste_data->files,
position);
gth_browser_exec_task (browser, task, GTH_TASK_FLAGS_DEFAULT);
g_object_unref (task);
paste_data_free (paste_data);
}
static void
ok_clicked_cb (GtkWidget *widget,
DialogData *data)
{
char *s_value;
GFile *destination;
int i_value;
const char *header;
const char *footer;
const char *image_page_header;
const char *image_page_footer;
char *thumbnail_caption;
char *image_attributes;
GtkTreeIter iter;
char *theme_name;
GthFileDataSort *sort_type;
GthTask *task;
/* save the options */
s_value = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (GET_WIDGET ("destination_filechooserbutton")));
destination = g_file_new_for_uri (s_value);
_g_settings_set_uri (data->settings, PREF_WEBALBUMS_DESTINATION, s_value);
g_free (s_value);
g_settings_set_boolean (data->settings, PREF_WEBALBUMS_COPY_IMAGES, gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("copy_images_checkbutton"))));
g_settings_set_boolean (data->settings, PREF_WEBALBUMS_RESIZE_IMAGES, gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("resize_images_checkbutton"))));
i_value = gtk_combo_box_get_active (GTK_COMBO_BOX (GET_WIDGET ("resize_images_combobox")));
g_settings_set_int (data->settings, PREF_WEBALBUMS_RESIZE_WIDTH, ImageSizeValues[i_value].width);
g_settings_set_int (data->settings, PREF_WEBALBUMS_RESIZE_HEIGHT, ImageSizeValues[i_value].height);
g_settings_set_int (data->settings, PREF_WEBALBUMS_IMAGES_PER_INDEX, gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (GET_WIDGET ("images_per_index_spinbutton"))));
g_settings_set_boolean (data->settings, PREF_WEBALBUMS_SINGLE_INDEX, gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("single_index_checkbutton"))));
g_settings_set_int (data->settings, PREF_WEBALBUMS_COLUMNS, gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (GET_WIDGET ("cols_spinbutton"))));
g_settings_set_boolean (data->settings, PREF_WEBALBUMS_ADAPT_TO_WIDTH, gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("adapt_column_checkbutton"))));
if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (GET_WIDGET ("sort_combobox")), &iter)) {
GthFileDataSort *sort_type;
gtk_tree_model_get (GTK_TREE_MODEL (GET_WIDGET ("sort_liststore")),
&iter,
SORT_TYPE_COLUMN_DATA, &sort_type,
-1);
g_settings_set_string (data->settings, PREF_WEBALBUMS_SORT_TYPE, sort_type->name);
}
g_settings_set_boolean (data->settings, PREF_WEBALBUMS_SORT_INVERSE, gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("reverse_order_checkbutton"))));
header = gtk_entry_get_text (GTK_ENTRY (GET_WIDGET ("header_entry")));
g_settings_set_string (data->settings, PREF_WEBALBUMS_HEADER, header);
footer = gtk_entry_get_text (GTK_ENTRY (GET_WIDGET ("footer_entry")));
g_settings_set_string (data->settings, PREF_WEBALBUMS_FOOTER, footer);
image_page_header = gtk_entry_get_text (GTK_ENTRY (GET_WIDGET ("image_page_header_entry")));
g_settings_set_string (data->settings, PREF_WEBALBUMS_IMAGE_PAGE_HEADER, image_page_header);
image_page_footer = gtk_entry_get_text (GTK_ENTRY (GET_WIDGET ("image_page_footer_entry")));
g_settings_set_string (data->settings, PREF_WEBALBUMS_IMAGE_PAGE_FOOTER, image_page_footer);
theme_name = NULL;
{
GList *list;
list = gtk_icon_view_get_selected_items (GTK_ICON_VIEW (GET_WIDGET ("theme_iconview")));
if (list != NULL) {
GtkTreePath *path;
GtkTreeIter iter;
path = g_list_first (list)->data;
gtk_tree_model_get_iter (GTK_TREE_MODEL (GET_WIDGET ("theme_liststore")), &iter, path);
gtk_tree_model_get (GTK_TREE_MODEL (GET_WIDGET ("theme_liststore")), &iter,
THEME_COLUMN_NAME, &theme_name,
-1);
}
g_list_foreach (list, (GFunc) gtk_tree_path_free, NULL);
g_list_free (list);
}
g_return_if_fail (theme_name != NULL);
g_settings_set_string (data->settings, PREF_WEBALBUMS_THEME, theme_name);
g_settings_set_boolean (data->settings, PREF_WEBALBUMS_ENABLE_THUMBNAIL_CAPTION, gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("thumbnail_caption_checkbutton"))));
thumbnail_caption = gth_metadata_chooser_get_selection (GTH_METADATA_CHOOSER (data->thumbnail_caption_chooser));
g_settings_set_string (data->settings, PREF_WEBALBUMS_THUMBNAIL_CAPTION, thumbnail_caption);
g_settings_set_boolean (data->settings, PREF_WEBALBUMS_ENABLE_IMAGE_ATTRIBUTES, gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("image_attributes_checkbutton"))));
g_settings_set_boolean (data->settings, PREF_WEBALBUMS_ENABLE_IMAGE_DESCRIPTION, gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("image_description_checkbutton"))));
image_attributes = gth_metadata_chooser_get_selection (GTH_METADATA_CHOOSER (data->image_attributes_chooser));
g_settings_set_string (data->settings, PREF_WEBALBUMS_IMAGE_ATTRIBUTES, image_attributes);
/* exec the task */
task = gth_web_exporter_new (data->browser, data->file_list);
gth_web_exporter_set_header (GTH_WEB_EXPORTER (task), header);
gth_web_exporter_set_footer (GTH_WEB_EXPORTER (task), footer);
gth_web_exporter_set_image_page_header (GTH_WEB_EXPORTER (task), image_page_header);
gth_web_exporter_set_image_page_footer (GTH_WEB_EXPORTER (task), image_page_footer);
gth_web_exporter_set_style (GTH_WEB_EXPORTER (task), theme_name);
gth_web_exporter_set_destination (GTH_WEB_EXPORTER (task), destination);
gth_web_exporter_set_copy_images (GTH_WEB_EXPORTER (task),
g_settings_get_boolean (data->settings, PREF_WEBALBUMS_COPY_IMAGES));
gth_web_exporter_set_resize_images (GTH_WEB_EXPORTER (task),
g_settings_get_boolean (data->settings, PREF_WEBALBUMS_RESIZE_IMAGES),
g_settings_get_int (data->settings, PREF_WEBALBUMS_RESIZE_WIDTH),
g_settings_get_int (data->settings, PREF_WEBALBUMS_RESIZE_HEIGHT));
s_value = g_settings_get_string (data->settings, PREF_WEBALBUMS_SORT_TYPE);
sort_type = gth_main_get_sort_type (s_value);
gth_web_exporter_set_sort_order (GTH_WEB_EXPORTER (task),
sort_type,
g_settings_get_boolean (data->settings, PREF_WEBALBUMS_SORT_INVERSE));
g_free (s_value);
gth_web_exporter_set_images_per_index (GTH_WEB_EXPORTER (task),
g_settings_get_int (data->settings, PREF_WEBALBUMS_IMAGES_PER_INDEX));
gth_web_exporter_set_single_index (GTH_WEB_EXPORTER (task),
g_settings_get_boolean (data->settings, PREF_WEBALBUMS_SINGLE_INDEX));
gth_web_exporter_set_columns (GTH_WEB_EXPORTER (task),
g_settings_get_int (data->settings, PREF_WEBALBUMS_COLUMNS));
gth_web_exporter_set_adapt_to_width (GTH_WEB_EXPORTER (task),
g_settings_get_boolean (data->settings, PREF_WEBALBUMS_ADAPT_TO_WIDTH));
gth_web_exporter_set_thumbnail_caption (GTH_WEB_EXPORTER (task),
gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("thumbnail_caption_checkbutton"))) ? thumbnail_caption : "");
gth_web_exporter_set_image_attributes (GTH_WEB_EXPORTER (task),
gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("image_description_checkbutton"))),
gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("image_attributes_checkbutton"))) ? image_attributes : "");
gth_browser_exec_task (data->browser, task, FALSE);
gtk_widget_destroy (data->dialog);
g_object_unref (task);
g_free (image_attributes);
g_free (thumbnail_caption);
g_free (theme_name);
g_object_unref (destination);
}