void
eel_gtk_message_dialog_set_details_label (GtkMessageDialog *dialog,
const gchar *details_text)
{
GtkWidget *content_area, *expander, *label;
content_area = gtk_message_dialog_get_message_area (dialog);
expander = gtk_expander_new_with_mnemonic (_("Show more _details"));
gtk_expander_set_spacing (GTK_EXPANDER (expander), 6);
label = gtk_label_new (details_text);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_label_set_selectable (GTK_LABEL (label), TRUE);
#if GTK_CHECK_VERSION (3, 16, 0)
gtk_label_set_xalign (GTK_LABEL (label), 0);
#else
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
#endif
gtk_container_add (GTK_CONTAINER (expander), label);
gtk_box_pack_start (GTK_BOX (content_area), expander, FALSE, FALSE, 0);
gtk_widget_show (label);
gtk_widget_show (expander);
}
static gchar *facebook_get_user_auth_token_from_url(dt_storage_facebook_gui_data_t *ui)
{
///////////// open the authentication url in a browser. just use some port, we won't listen anyway
if(!_open_browser("http://localhost:8123/" FB_CALLBACK_ID)) return NULL;
////////////// build & show the validation dialog
gchar *text1 = _("step 1: a new window or tab of your browser should have been "
"loaded. you have to login into your facebook account there "
"and authorize darktable to upload photos before continuing.");
gchar *text2 = _("step 2: paste your browser URL and click the OK button once "
"you are done.");
GtkWidget *window = dt_ui_main_window(darktable.gui->ui);
GtkDialog *fb_auth_dialog = GTK_DIALOG(
gtk_message_dialog_new(GTK_WINDOW(window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_QUESTION,
GTK_BUTTONS_OK_CANCEL, _("facebook authentication")));
gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(fb_auth_dialog), "%s\n\n%s", text1, text2);
GtkWidget *entry = gtk_entry_new();
GtkWidget *hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(gtk_label_new(_("URL:"))), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(entry), TRUE, TRUE, 0);
GtkWidget *fbauthdialog_vbox = gtk_message_dialog_get_message_area(GTK_MESSAGE_DIALOG(fb_auth_dialog));
gtk_box_pack_end(GTK_BOX(fbauthdialog_vbox), hbox, TRUE, TRUE, 0);
gtk_widget_show_all(GTK_WIDGET(fb_auth_dialog));
////////////// wait for the user to enter the validation URL
gint result;
gchar *token = NULL;
const char *replyurl;
while(TRUE)
{
result = gtk_dialog_run(GTK_DIALOG(fb_auth_dialog));
if(result == GTK_RESPONSE_CANCEL) break;
replyurl = gtk_entry_get_text(GTK_ENTRY(entry));
if(replyurl == NULL || g_strcmp0(replyurl, "") == 0)
{
gtk_message_dialog_format_secondary_markup(GTK_MESSAGE_DIALOG(fb_auth_dialog),
"%s\n\n%s\n\n<span foreground=\"" MSGCOLOR_RED
"\" ><small>%s</small></span>",
text1, text2, _("please enter the validation URL"));
continue;
}
token = fb_extract_token_from_url(replyurl);
if(token != NULL) // we have a valid token
break;
else
gtk_message_dialog_format_secondary_markup(
GTK_MESSAGE_DIALOG(fb_auth_dialog),
"%s\n\n%s%s\n\n<span foreground=\"" MSGCOLOR_RED "\"><small>%s</small></span>", text1, text2,
_("the given URL is not valid, it should look like: "),
FB_WS_BASE_URL "connect/login_success.html?...");
}
gtk_widget_destroy(GTK_WIDGET(fb_auth_dialog));
return token;
}
void show_error_dialog(GmpvApplication *app, const gchar *prefix, const gchar *msg)
{
GmpvMainWindow *wnd;
GtkWidget *dialog;
GtkWidget *msg_area;
GList *iter;
wnd = gmpv_application_get_main_window(app);
dialog = gtk_message_dialog_new
( GTK_WINDOW(wnd),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_OK,
_("Error") );
msg_area = gtk_message_dialog_get_message_area
(GTK_MESSAGE_DIALOG(dialog));
iter = gtk_container_get_children(GTK_CONTAINER(msg_area));
while(iter)
{
if(GTK_IS_LABEL(iter->data))
{
GtkLabel *label = iter->data;
gtk_label_set_line_wrap_mode
(label, PANGO_WRAP_WORD_CHAR);
}
iter = g_list_next(iter);
}
g_list_free(iter);
if(prefix)
{
gchar *prefix_escaped = g_markup_printf_escaped("%s", prefix);
gchar *msg_escaped = g_markup_printf_escaped("%s", msg);
gtk_message_dialog_format_secondary_markup
( GTK_MESSAGE_DIALOG(dialog),
"<b>[%s]</b> %s",
prefix_escaped,
msg_escaped );
g_free(prefix_escaped);
g_free(msg_escaped);
}
else
{
gtk_message_dialog_format_secondary_text
(GTK_MESSAGE_DIALOG(dialog), "%s", msg);
}
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
}
static GObject *
gtk_message_dialog_buildable_get_internal_child (GtkBuildable *buildable,
GtkBuilder *builder,
const gchar *childname)
{
if (strcmp (childname, "message_area") == 0)
return G_OBJECT (gtk_message_dialog_get_message_area (GTK_MESSAGE_DIALOG (buildable)));
return parent_buildable_iface->get_internal_child (buildable, builder, childname);
}
static void
menu_state_changed_callback (NemoMainApplication *self)
{
if (!g_settings_get_boolean (nemo_window_state, NEMO_WINDOW_STATE_START_WITH_MENU_BAR) &&
!g_settings_get_boolean (nemo_preferences, NEMO_PREFERENCES_DISABLE_MENU_WARNING)) {
GtkWidget *dialog;
GtkWidget *msg_area;
GtkWidget *checkbox;
dialog = gtk_message_dialog_new (NULL,
GTK_DIALOG_MODAL,
GTK_MESSAGE_INFO,
GTK_BUTTONS_OK,
_("Nemo's main menu is now hidden"));
gchar *secondary;
secondary = g_strdup_printf (_("You have chosen to hide the main menu. You can get it back temporarily by:\n\n"
"- Tapping the <Alt> key\n"
"- Right-clicking an empty region of the main toolbar\n"
"- Right-clicking an empty region of the status bar.\n\n"
"You can restore it permanently by selecting this option again from the View menu."));
g_object_set (dialog,
"secondary-text", secondary,
NULL);
g_free (secondary);
msg_area = gtk_message_dialog_get_message_area (GTK_MESSAGE_DIALOG (dialog));
checkbox = gtk_check_button_new_with_label (_("Don't show this message again."));
gtk_box_pack_start (GTK_BOX (msg_area), checkbox, TRUE, TRUE, 2);
g_settings_bind (nemo_preferences,
NEMO_PREFERENCES_DISABLE_MENU_WARNING,
checkbox,
"active",
G_SETTINGS_BIND_DEFAULT);
gtk_widget_show_all (dialog);
g_signal_connect (dialog, "response",
G_CALLBACK (gtk_widget_destroy), NULL);
}
}
static void
do_simple_message_box(ESD_TYPE_E type, gboolean *notagain,
const char *secondary_msg, const char *msg_format,
va_list ap)
{
QMessageBox *msg_dialog;
gchar *message;
if (notagain != NULL) {
if (*notagain) {
/*
* The user had checked the "Don't show this message again" checkbox
* in the past; don't bother showing it.
*/
return;
}
}
/*
* XXX - this should be passed the main window.
* Also, this should be set to window modal by setting its window
* modality to Qt::WindowModal, so it shows up as a sheet in
* OS X.
*/
msg_dialog = new QMessageBox(NULL);
switch (type) {
case ESD_TYPE_INFO:
msg_dialog->setIcon(QMessageBox::Information);
break;
case ESD_TYPE_WARN:
msg_dialog->setIcon(QMessageBox::Warning);
break;
case ESD_TYPE_ERROR:
msg_dialog->setIcon(QMessageBox::Critical);
break;
default:
g_assert_not_reached();
return;
}
/* Format the message. */
message = g_strdup_vprintf(msg_format, ap);
msg_dialog->setText(message);
g_free(message);
/* Add the secondary text. */
if (secondary_msg != NULL)
msg_dialog->setInformativeText(secondary_msg);
#if 0
if (notagain != NULL) {
checkbox = gtk_check_button_new_with_label("Don't show this message again.");
gtk_container_set_border_width(GTK_CONTAINER(checkbox), 12);
gtk_box_pack_start(GTK_BOX(gtk_message_dialog_get_message_area(GTK_MESSAGE_DIALOG(msg_dialog))), checkbox,
TRUE, TRUE, 0);
gtk_widget_show(checkbox);
}
#endif
msg_dialog->exec();
#if 0
if (notagain != NULL) {
/*
* OK, did they check the checkbox?
*/
*notagain = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(checkbox));
}
#endif
delete msg_dialog;
}
/*
* Block contact dialog
*/
gboolean
empathy_block_individual_dialog_show (GtkWindow *parent,
FolksIndividual *individual,
GdkPixbuf *avatar,
gboolean *abusive)
{
GtkWidget *dialog;
GtkWidget *abusive_check = NULL;
GeeSet *personas;
GeeIterator *iter;
GString *text = g_string_new ("");
GString *blocked_str = g_string_new ("");
GString *notblocked_str = g_string_new ("");
guint npersonas_blocked = 0, npersonas_notblocked = 0;
gboolean can_report_abuse = FALSE;
int res;
dialog = gtk_message_dialog_new (parent,
GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_NONE,
_("Block %s?"),
folks_alias_details_get_alias (FOLKS_ALIAS_DETAILS (individual)));
if (avatar != NULL)
{
GtkWidget *image = gtk_image_new_from_pixbuf (avatar);
gtk_message_dialog_set_image (GTK_MESSAGE_DIALOG (dialog), image);
gtk_widget_show (image);
}
/* build a list of personas that support blocking */
personas = folks_individual_get_personas (individual);
iter = gee_iterable_iterator (GEE_ITERABLE (personas));
while (gee_iterator_next (iter))
{
TpfPersona *persona = gee_iterator_get (iter);
TpContact *contact;
GString *s;
char *str;
TpConnection *conn;
if (!TPF_IS_PERSONA (persona))
goto while_finish;
contact = tpf_persona_get_contact (persona);
if (contact == NULL)
goto while_finish;
conn = tp_contact_get_connection (contact);
if (tp_proxy_has_interface_by_id (conn,
TP_IFACE_QUARK_CONNECTION_INTERFACE_CONTACT_BLOCKING))
{
s = blocked_str;
npersonas_blocked++;
}
else
{
s = notblocked_str;
npersonas_notblocked++;
}
if (tp_connection_can_report_abusive (conn))
can_report_abuse = TRUE;
str = contact_pretty_name (contact);
g_string_append_printf (s, "\n " BULLET_POINT " %s", str);
g_free (str);
while_finish:
g_clear_object (&persona);
}
g_clear_object (&iter);
g_string_append_printf (text,
_("Are you sure you want to block '%s' from contacting you again?"),
folks_alias_details_get_alias (FOLKS_ALIAS_DETAILS (individual)));
if (npersonas_blocked > 0)
g_string_append_printf (text, "\n\n%s\n%s",
ngettext ("The following identity will be blocked:",
"The following identities will be blocked:",
npersonas_blocked),
blocked_str->str);
if (npersonas_notblocked > 0)
g_string_append_printf (text, "\n\n%s\n%s",
ngettext ("The following identity can not be blocked:",
"The following identities can not be blocked:",
npersonas_notblocked),
notblocked_str->str);
gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
"%s", text->str);
gtk_dialog_add_buttons (GTK_DIALOG (dialog),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
_("_Block"), GTK_RESPONSE_REJECT,
NULL);
if (can_report_abuse)
{
GtkWidget *vbox;
vbox = gtk_message_dialog_get_message_area (GTK_MESSAGE_DIALOG (dialog));
abusive_check = gtk_check_button_new_with_mnemonic (
ngettext ("_Report this contact as abusive",
"_Report these contacts as abusive",
npersonas_blocked));
gtk_box_pack_start (GTK_BOX (vbox), abusive_check, FALSE, TRUE, 0);
gtk_widget_show (abusive_check);
}
g_string_free (text, TRUE);
g_string_free (blocked_str, TRUE);
g_string_free (notblocked_str, TRUE);
res = gtk_dialog_run (GTK_DIALOG (dialog));
if (abusive != NULL)
{
if (abusive_check != NULL)
*abusive = gtk_toggle_button_get_active (
GTK_TOGGLE_BUTTON (abusive_check));
else
*abusive = FALSE;
}
gtk_widget_destroy (dialog);
return res == GTK_RESPONSE_REJECT;
}
EXPORT void audgui_dialog_add_widget (GtkWidget * dialog, GtkWidget * widget)
{
GtkWidget * box = gtk_message_dialog_get_message_area ((GtkMessageDialog *) dialog);
gtk_box_pack_start ((GtkBox *) box, widget, FALSE, FALSE, 0);
}
GtkWidget *
do_expander (GtkWidget *do_widget)
{
GtkWidget *toplevel;
GtkWidget *area;
GtkWidget *expander;
GtkWidget *sw;
GtkWidget *tv;
GtkTextBuffer *buffer;
if (!window)
{
toplevel = gtk_widget_get_toplevel (do_widget);
window = gtk_message_dialog_new_with_markup (GTK_WINDOW (toplevel),
0,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
"<big><b>%s</b></big>",
"Something went wrong");
gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (window),
"Here are some more details "
"but not the full story.");
area = gtk_message_dialog_get_message_area (GTK_MESSAGE_DIALOG (window));
expander = gtk_expander_new ("Details:");
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_min_content_height (GTK_SCROLLED_WINDOW (sw), 100);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
tv = gtk_text_view_new ();
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (tv));
gtk_text_view_set_editable (GTK_TEXT_VIEW (tv), FALSE);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (tv), GTK_WRAP_WORD);
gtk_text_buffer_set_text (GTK_TEXT_BUFFER (buffer),
"Finally, the full story with all details. "
"And all the inside information, including "
"error codes, etc etc. Pages of information, "
"you might have to scroll down to read it all, "
"or even resize the window - it works !\n"
"A second paragraph will contain even more "
"innuendo, just to make you scroll down or "
"resize the window. Do it already !", -1);
gtk_container_add (GTK_CONTAINER (sw), tv);
gtk_container_add (GTK_CONTAINER (expander), sw);
gtk_box_pack_end (GTK_BOX (area), expander);
g_signal_connect (expander, "notify::expanded",
G_CALLBACK (expander_cb), window);
g_signal_connect (window, "response", G_CALLBACK (response_cb), NULL);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
return window;
}
static gboolean
handle_access_dialog (XdpImplAccess *object,
GDBusMethodInvocation *invocation,
const char *arg_handle,
const char *arg_app_id,
const char *arg_parent_window,
const char *arg_title,
const char *arg_subtitle,
const char *arg_body,
GVariant *arg_options)
{
g_autoptr(Request) request = NULL;
const char *sender;
AccessDialogHandle *handle;
g_autoptr(GError) error = NULL;
g_autofree char *filename = NULL;
gboolean modal;
GtkWidget *dialog;
GdkWindow *foreign_parent = NULL;
const char *deny_label;
const char *grant_label;
const char *icon;
g_autoptr(GVariant) choices = NULL;
GtkWidget *area;
GtkWidget *image;
GHashTable *choice_table = NULL;
sender = g_dbus_method_invocation_get_sender (invocation);
request = request_new (sender, arg_app_id, arg_handle);
if (!g_variant_lookup (arg_options, "modal", "b", &modal))
modal = TRUE;
if (!g_variant_lookup (arg_options, "deny_label", "&s", &deny_label))
deny_label = _("Deny Access");
if (!g_variant_lookup (arg_options, "grant_label", "&s", &grant_label))
grant_label = _("Grant Access");
if (!g_variant_lookup (arg_options, "icon", "&s", &icon))
icon = NULL;
choices = g_variant_lookup_value (arg_options, "choices", G_VARIANT_TYPE ("a(ssa(ss)s)"));
dialog = gtk_message_dialog_new (NULL,
0,
GTK_MESSAGE_QUESTION,
GTK_BUTTONS_NONE,
arg_title,
NULL);
gtk_window_set_modal (GTK_WINDOW (dialog), modal);
gtk_dialog_add_button (GTK_DIALOG (dialog), deny_label, GTK_RESPONSE_CANCEL);
gtk_dialog_add_button (GTK_DIALOG (dialog), grant_label, GTK_RESPONSE_OK);
gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), "%s", arg_subtitle);
area = gtk_message_dialog_get_message_area (GTK_MESSAGE_DIALOG (dialog));
fix_up_label_alignment (area);
if (choices)
{
int i;
choice_table = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
for (i = 0; i < g_variant_n_children (choices); i++)
add_choice (area, g_variant_get_child_value (choices, i), choice_table);
}
if (!g_str_equal (arg_body, ""))
{
GtkWidget *body_label;
body_label = gtk_label_new (arg_body);
gtk_widget_set_halign (body_label, GTK_ALIGN_START);
g_object_set (body_label, "margin-top", 10, NULL);
gtk_label_set_xalign (GTK_LABEL (body_label), 0);
gtk_label_set_line_wrap (GTK_LABEL (body_label), TRUE);
gtk_label_set_max_width_chars (GTK_LABEL (body_label), 50);
gtk_widget_show (body_label);
gtk_container_add (GTK_CONTAINER (area), body_label);
}
image = gtk_image_new_from_icon_name (icon ? icon : "image-missing", GTK_ICON_SIZE_DIALOG);
gtk_widget_set_opacity (image, icon ? 1.0 : 0.0);
gtk_widget_show (image);
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
gtk_message_dialog_set_image (GTK_MESSAGE_DIALOG (dialog), image);
G_GNUC_END_IGNORE_DEPRECATIONS
#ifdef GDK_WINDOWING_X11
if (g_str_has_prefix (arg_parent_window, "x11:"))
{
int xid;
if (sscanf (arg_parent_window, "x11:%x", &xid) != 1)
g_warning ("invalid xid");
else
foreign_parent = gdk_x11_window_foreign_new_for_display (gtk_widget_get_display (dialog), xid);
}
#endif
else
g_warning ("Unhandled parent window type %s", arg_parent_window);
handle = g_new0 (AccessDialogHandle, 1);
handle->impl = object;
handle->invocation = invocation;
handle->request = g_object_ref (request);
handle->dialog = g_object_ref (dialog);
handle->choices = choice_table;
g_signal_connect (request, "handle-close", G_CALLBACK (handle_close), handle);
g_signal_connect (dialog, "response", G_CALLBACK (access_dialog_response), handle);
gtk_widget_realize (dialog);
if (foreign_parent)
gdk_window_set_transient_for (gtk_widget_get_window (dialog), foreign_parent);
gtk_widget_show (dialog);
request_export (request, g_dbus_method_invocation_get_connection (invocation));
return TRUE;
}
/**
* @see https://developers.facebook.com/docs/authentication/
* @returs NULL if the user cancel the operation or a valid token
*/
static gchar *facebook_get_user_auth_token(dt_storage_facebook_gui_data_t *ui)
{
///////////// open the authentication url in a browser
GError *error = NULL;
if(!gtk_show_uri(gdk_screen_get_default(), FB_WS_BASE_URL
"dialog/oauth?"
"client_id=" FB_API_KEY "&redirect_uri=" FB_WS_BASE_URL "connect/login_success.html"
"&scope=user_photos,publish_stream"
"&response_type=token",
gtk_get_current_event_time(), &error))
{
fprintf(stderr, "[facebook] error opening browser: %s\n", error->message);
g_error_free(error);
}
////////////// build & show the validation dialog
gchar *text1 = _("step 1: a new window or tab of your browser should have been "
"loaded. you have to login into your facebook account there "
"and authorize darktable to upload photos before continuing.");
gchar *text2 = _("step 2: paste your browser URL and click the OK button once "
"you are done.");
GtkWidget *window = dt_ui_main_window(darktable.gui->ui);
GtkDialog *fb_auth_dialog = GTK_DIALOG(
gtk_message_dialog_new(GTK_WINDOW(window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_QUESTION,
GTK_BUTTONS_OK_CANCEL, _("facebook authentication")));
gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(fb_auth_dialog), "%s\n\n%s", text1, text2);
GtkWidget *entry = gtk_entry_new();
GtkWidget *hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(gtk_label_new(_("URL:"))), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(entry), TRUE, TRUE, 0);
GtkWidget *fbauthdialog_vbox = gtk_message_dialog_get_message_area(GTK_MESSAGE_DIALOG(fb_auth_dialog));
gtk_box_pack_end(GTK_BOX(fbauthdialog_vbox), hbox, TRUE, TRUE, 0);
gtk_widget_show_all(GTK_WIDGET(fb_auth_dialog));
////////////// wait for the user to enter the validation URL
gint result;
gchar *token = NULL;
const char *replyurl;
while(TRUE)
{
result = gtk_dialog_run(GTK_DIALOG(fb_auth_dialog));
if(result == GTK_RESPONSE_CANCEL) break;
replyurl = gtk_entry_get_text(GTK_ENTRY(entry));
if(replyurl == NULL || g_strcmp0(replyurl, "") == 0)
{
gtk_message_dialog_format_secondary_markup(GTK_MESSAGE_DIALOG(fb_auth_dialog),
"%s\n\n%s\n\n<span foreground=\"" MSGCOLOR_RED
"\" ><small>%s</small></span>",
text1, text2, _("please enter the validation URL"));
continue;
}
token = fb_extract_token_from_url(replyurl);
if(token != NULL) // we have a valid token
break;
else
gtk_message_dialog_format_secondary_markup(
GTK_MESSAGE_DIALOG(fb_auth_dialog),
"%s\n\n%s%s\n\n<span foreground=\"" MSGCOLOR_RED "\"><small>%s</small></span>", text1, text2,
_("the given URL is not valid, it should look like: "),
FB_WS_BASE_URL "connect/login_success.html?...");
}
gtk_widget_destroy(GTK_WIDGET(fb_auth_dialog));
return token;
}
/*
* Save changes of the ETFile (write tag and rename file)
* - multiple_files = TRUE : when saving files, a msgbox appears with ability
* to do the same action for all files.
* - multiple_files = FALSE : appears only a msgbox to ask confirmation.
*/
static gint
Save_File (ET_File *ETFile, gboolean multiple_files,
gboolean force_saving_files)
{
const File_Tag *FileTag;
const File_Name *FileNameNew;
gint stop_loop = 0;
const gchar *filename_cur_utf8 = ((File_Name *)ETFile->FileNameCur->data)->value_utf8;
const gchar *filename_new_utf8 = ((File_Name *)ETFile->FileNameNew->data)->value_utf8;
gchar *basename_cur_utf8, *basename_new_utf8;
gchar *dirname_cur_utf8, *dirname_new_utf8;
g_return_val_if_fail (ETFile != NULL, 0);
basename_cur_utf8 = g_path_get_basename(filename_cur_utf8);
basename_new_utf8 = g_path_get_basename(filename_new_utf8);
/* Save the current displayed data */
//ET_Save_File_Data_From_UI((ET_File *)ETFileList->data); // Not needed, because it was done before
FileTag = ETFile->FileTag->data;
FileNameNew = ETFile->FileNameNew->data;
/*
* Check if file was changed by an external program
*/
/*stat(filename_cur,&statbuf);
if (ETFile->FileModificationTime != statbuf.st_mtime)
{
// File was changed
GtkWidget *msgbox = NULL;
gint response;
msg = g_strdup_printf(_("The file '%s' was changed by an external program.\nDo you want to continue?"),basename_cur_utf8);
msgbox = msg_box_new(_("Write File"),
GTK_WINDOW(MainWindow),
NULL,
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
msg,
GTK_STOCK_DIALOG_WARNING,
GTK_STOCK_NO, GTK_RESPONSE_NO,
GTK_STOCK_YES, GTK_RESPONSE_YES,
NULL);
g_free(msg);
response = gtk_dialog_run(GTK_DIALOG(msgbox));
gtk_widget_destroy(msgbox);
switch (response)
{
case GTK_RESPONSE_YES:
break;
case GTK_RESPONSE_NO:
case GTK_RESPONSE_NONE:
stop_loop = -1;
return stop_loop;
break;
}
}*/
/*
* First part: write tag information (artist, title,...)
*/
// Note : the option 'force_saving_files' is only used to save tags
if ( force_saving_files
|| FileTag->saved == FALSE ) // This tag had been already saved ?
{
GtkWidget *msgdialog = NULL;
GtkWidget *msgdialog_check_button = NULL;
gint response;
if (g_settings_get_boolean (MainSettings, "confirm-write-tags")
&& !SF_HideMsgbox_Write_Tag)
{
// ET_Display_File_Data_To_UI(ETFile);
msgdialog = gtk_message_dialog_new(GTK_WINDOW(MainWindow),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_QUESTION,
GTK_BUTTONS_NONE,
_("Do you want to write the tag of file ‘%s’?"),
basename_cur_utf8);
gtk_window_set_title(GTK_WINDOW(msgdialog),_("Confirm Tag Writing"));
if (multiple_files)
{
GtkWidget *message_area;
message_area = gtk_message_dialog_get_message_area(GTK_MESSAGE_DIALOG(msgdialog));
msgdialog_check_button = gtk_check_button_new_with_label(_("Repeat action for the remaining files"));
gtk_container_add(GTK_CONTAINER(message_area),msgdialog_check_button);
gtk_widget_show (msgdialog_check_button);
gtk_dialog_add_buttons (GTK_DIALOG (msgdialog),
_("_Discard"), GTK_RESPONSE_NO,
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_Save"), GTK_RESPONSE_YES, NULL);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(msgdialog_check_button), TRUE); // Checked by default
}
else
{
gtk_dialog_add_buttons (GTK_DIALOG (msgdialog),
_("_Cancel"), GTK_RESPONSE_NO,
_("_Save"), GTK_RESPONSE_YES, NULL);
}
gtk_dialog_set_default_response (GTK_DIALOG (msgdialog),
GTK_RESPONSE_YES);
SF_ButtonPressed_Write_Tag = response = gtk_dialog_run(GTK_DIALOG(msgdialog));
// When check button in msgbox was activated : do not display the message again
if (msgdialog_check_button && gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(msgdialog_check_button)))
SF_HideMsgbox_Write_Tag = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(msgdialog_check_button));
gtk_widget_destroy(msgdialog);
}else
{
if (SF_HideMsgbox_Write_Tag)
response = SF_ButtonPressed_Write_Tag;
else
response = GTK_RESPONSE_YES;
}
switch (response)
{
case GTK_RESPONSE_YES:
{
gboolean rc;
// if 'SF_HideMsgbox_Write_Tag is TRUE', then errors are displayed only in log
rc = Write_File_Tag(ETFile,SF_HideMsgbox_Write_Tag);
// if an error occurs when 'SF_HideMsgbox_Write_Tag is TRUE', we don't stop saving...
if (rc != TRUE && !SF_HideMsgbox_Write_Tag)
{
stop_loop = -1;
g_free (basename_cur_utf8);
g_free (basename_new_utf8);
return stop_loop;
}
break;
}
case GTK_RESPONSE_NO:
break;
case GTK_RESPONSE_CANCEL:
case GTK_RESPONSE_DELETE_EVENT:
stop_loop = -1;
g_free (basename_cur_utf8);
g_free (basename_new_utf8);
return stop_loop;
break;
default:
g_assert_not_reached ();
break;
}
}
/*
* Second part: rename the file
*/
// Do only if changed! (don't take force_saving_files into account)
if ( FileNameNew->saved == FALSE ) // This filename had been already saved ?
{
GtkWidget *msgdialog = NULL;
GtkWidget *msgdialog_check_button = NULL;
gint response;
if (g_settings_get_boolean (MainSettings, "confirm-rename-file")
&& !SF_HideMsgbox_Rename_File)
{
gchar *msgdialog_title = NULL;
gchar *msg = NULL;
gchar *msg1 = NULL;
// ET_Display_File_Data_To_UI(ETFile);
dirname_cur_utf8 = g_path_get_dirname(filename_cur_utf8);
dirname_new_utf8 = g_path_get_dirname(filename_new_utf8);
// Directories were renamed? or only filename?
if (g_utf8_collate(dirname_cur_utf8,dirname_new_utf8) != 0)
{
if (g_utf8_collate(basename_cur_utf8,basename_new_utf8) != 0)
{
// Directories and filename changed
msgdialog_title = g_strdup (_("Rename File and Directory"));
msg = g_strdup(_("File and directory rename confirmation required"));
msg1 = g_strdup_printf (_("Do you want to rename the file and directory ‘%s’ to ‘%s’?"),
filename_cur_utf8, filename_new_utf8);
}else
{
// Only directories changed
msgdialog_title = g_strdup (_("Rename Directory"));
msg = g_strdup(_("Directory rename confirmation required"));
msg1 = g_strdup_printf (_("Do you want to rename the directory ‘%s’ to ‘%s’?"),
dirname_cur_utf8,
dirname_new_utf8);
}
}else
{
// Only filename changed
msgdialog_title = g_strdup (_("Rename File"));
msg = g_strdup(_("File rename confirmation required"));
msg1 = g_strdup_printf (_("Do you want to rename the file ‘%s’ to ‘%s’?"),
basename_cur_utf8, basename_new_utf8);
}
g_free(dirname_cur_utf8);
g_free(dirname_new_utf8);
msgdialog = gtk_message_dialog_new(GTK_WINDOW(MainWindow),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_QUESTION,
GTK_BUTTONS_NONE,
"%s",
msg);
gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(msgdialog),"%s",msg1);
gtk_window_set_title(GTK_WINDOW(msgdialog),msgdialog_title);
if (multiple_files)
{
GtkWidget *message_area;
message_area = gtk_message_dialog_get_message_area(GTK_MESSAGE_DIALOG(msgdialog));
msgdialog_check_button = gtk_check_button_new_with_label(_("Repeat action for the remaining files"));
gtk_container_add(GTK_CONTAINER(message_area),msgdialog_check_button);
gtk_widget_show (msgdialog_check_button);
gtk_dialog_add_buttons (GTK_DIALOG (msgdialog), _("_Discard"),
GTK_RESPONSE_NO, _("_Cancel"),
GTK_RESPONSE_CANCEL, _("_Save"),
GTK_RESPONSE_YES, NULL);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(msgdialog_check_button), TRUE); // Checked by default
}
else
{
gtk_dialog_add_buttons (GTK_DIALOG (msgdialog), _("_Discard"),
GTK_RESPONSE_NO, _("_Save"),
GTK_RESPONSE_YES, NULL);
}
g_free(msg);
g_free(msg1);
g_free(msgdialog_title);
gtk_dialog_set_default_response (GTK_DIALOG (msgdialog),
GTK_RESPONSE_YES);
SF_ButtonPressed_Rename_File = response = gtk_dialog_run(GTK_DIALOG(msgdialog));
if (msgdialog_check_button && gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(msgdialog_check_button)))
SF_HideMsgbox_Rename_File = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(msgdialog_check_button));
gtk_widget_destroy(msgdialog);
}else
{
if (SF_HideMsgbox_Rename_File)
response = SF_ButtonPressed_Rename_File;
else
response = GTK_RESPONSE_YES;
}
switch(response)
{
case GTK_RESPONSE_YES:
{
gboolean rc;
GError *error = NULL;
const gchar *cur_filename = ((File_Name *)ETFile->FileNameCur->data)->value;
const gchar *new_filename = ((File_Name *)ETFile->FileNameNew->data)->value;
rc = et_rename_file (cur_filename, new_filename, &error);
// if 'SF_HideMsgbox_Rename_File is TRUE', then errors are displayed only in log
if (!rc)
{
if (!SF_HideMsgbox_Rename_File)
{
msgdialog = gtk_message_dialog_new (GTK_WINDOW (MainWindow),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
_("Cannot rename file ‘%s’ to ‘%s’"),
filename_cur_utf8,
filename_new_utf8);
gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (msgdialog),
"%s",
error->message);
gtk_window_set_title (GTK_WINDOW (msgdialog),
_("Rename File Error"));
gtk_dialog_run (GTK_DIALOG (msgdialog));
gtk_widget_destroy (msgdialog);
}
Log_Print (LOG_ERROR,
_("Cannot rename file ‘%s’ to ‘%s’: %s"),
filename_cur_utf8, filename_new_utf8,
error->message);
et_application_window_status_bar_message (ET_APPLICATION_WINDOW (MainWindow),
_("File(s) not renamed"),
TRUE);
g_error_free (error);
}
// if an error occurs when 'SF_HideMsgbox_Rename_File is TRUE', we don't stop saving...
if (!rc && !SF_HideMsgbox_Rename_File)
{
stop_loop = -1;
g_free (basename_cur_utf8);
g_free (basename_new_utf8);
return stop_loop;
}
/* Mark after renaming files. */
ETFile->FileNameCur = ETFile->FileNameNew;
ET_Mark_File_Name_As_Saved (ETFile);
break;
}
case GTK_RESPONSE_NO:
break;
case GTK_RESPONSE_CANCEL:
case GTK_RESPONSE_DELETE_EVENT:
stop_loop = -1;
g_free (basename_cur_utf8);
g_free (basename_new_utf8);
return stop_loop;
break;
default:
g_assert_not_reached ();
break;
}
}
g_free(basename_cur_utf8);
g_free(basename_new_utf8);
/* Refresh file into browser list */
// Browser_List_Refresh_File_In_List(ETFile);
return 1;
}
/**
* @see https://developers.google.com/accounts/docs/OAuth2InstalledApp
* @returns NULL if the user cancels the operation or a valid token
*/
static int gphoto_get_user_auth_token(dt_storage_gphoto_gui_data_t *ui)
{
///////////// open the authentication url in a browser
GError *error = NULL;
gchar *params = NULL;
params = dt_util_dstrcat(params,
GOOGLE_WS_BASE_URL
"o/oauth2/v2/auth?"
"client_id=%s&redirect_uri=urn:ietf:wg:oauth:2.0:oob"
"&scope=" GOOGLE_API_BASE_URL "auth/photoslibrary "
GOOGLE_API_BASE_URL "auth/userinfo.profile "
GOOGLE_API_BASE_URL "auth/userinfo.email"
"&response_type=code&access_type=offline",
ui->gphoto_api->google_client_id);
if(!gtk_show_uri(gdk_screen_get_default(), params, gtk_get_current_event_time(), &error))
{
fprintf(stderr, "[gphoto] error opening browser: %s\n", error->message);
g_error_free(error);
}
////////////// build & show the validation dialog
const gchar *text1 = _("step 1: a new window or tab of your browser should have been "
"loaded. you have to login into your google account there "
"and authorize darktable to upload photos before continuing.");
const gchar *text2 = _("step 2: paste the verification code shown to you in the browser "
"and click the OK button once you are done.");
GtkWidget *window = dt_ui_main_window(darktable.gui->ui);
GtkDialog *gphoto_auth_dialog = GTK_DIALOG(
gtk_message_dialog_new(GTK_WINDOW(window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_QUESTION,
GTK_BUTTONS_OK_CANCEL, _("google authentication")));
#ifdef GDK_WINDOWING_QUARTZ
dt_osx_disallow_fullscreen(GTK_WIDGET(gphoto_auth_dialog));
#endif
gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(gphoto_auth_dialog), "%s\n\n%s", text1, text2);
GtkWidget *entry = gtk_entry_new();
GtkWidget *hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(gtk_label_new(_("verification code:"))), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(entry), TRUE, TRUE, 0);
GtkWidget *gphotoauthdialog_vbox
= gtk_message_dialog_get_message_area(GTK_MESSAGE_DIALOG(gphoto_auth_dialog));
gtk_box_pack_end(GTK_BOX(gphotoauthdialog_vbox), hbox, TRUE, TRUE, 0);
gtk_widget_show_all(GTK_WIDGET(gphoto_auth_dialog));
////////////// wait for the user to enter the verification code
gint result;
gchar *token = NULL;
const char *replycode;
while(TRUE)
{
result = gtk_dialog_run(GTK_DIALOG(gphoto_auth_dialog));
if(result == GTK_RESPONSE_CANCEL) break;
replycode = gtk_entry_get_text(GTK_ENTRY(entry));
if(replycode == NULL || g_strcmp0(replycode, "") == 0)
{
gtk_message_dialog_format_secondary_markup(GTK_MESSAGE_DIALOG(gphoto_auth_dialog),
"%s\n\n%s\n\n<span foreground=\"" MSGCOLOR_RED
"\" ><small>%s</small></span>",
text1, text2, _("please enter the verification code"));
continue;
}
else
{
token = g_strdup(replycode);
break;
}
}
gtk_widget_destroy(GTK_WIDGET(gphoto_auth_dialog));
g_free(params);
if(result == GTK_RESPONSE_CANCEL)
return 1;
// Interchange now the authorization_code for an access_token and refresh_token
JsonObject *reply;
params = NULL;
params = dt_util_dstrcat(params, "code=%s&client_id=%s&client_secret=%s"
"&redirect_uri=" GOOGLE_URI "&grant_type=authorization_code",
token, ui->gphoto_api->google_client_id, ui->gphoto_api->google_client_secret);
g_free(token);
reply = gphoto_query_post_auth(ui->gphoto_api, GOOGLE_WS_BASE_URL "o/oauth2/token", params);
gchar *access_token = g_strdup(json_object_get_string_member(reply, "access_token"));
gchar *refresh_token = g_strdup(json_object_get_string_member(reply, "refresh_token"));
ui->gphoto_api->token = access_token;
ui->gphoto_api->refresh_token = refresh_token;
g_free(params);
return 0; // FIXME
}
GtkWidget *
_gtk_error_dialog_new (GtkWindow *parent,
GtkDialogFlags flags,
GList *row_output,
const char *primary_text,
const char *secondary_text_format,
...)
{
GtkWidget *dialog;
dialog = gtk_message_dialog_new (parent,
flags,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
"%s", primary_text);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_CLOSE);
if (flags & GTK_DIALOG_MODAL)
_gtk_dialog_add_to_window_group (GTK_DIALOG (dialog));
/* label */
if (secondary_text_format != NULL) {
va_list args;
char *secondary_message;
va_start (args, secondary_text_format);
secondary_message = g_strdup_vprintf (secondary_text_format, args);
va_end (args);
gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), "%s", secondary_message);
g_free (secondary_message);
}
/* output */
if ((row_output != NULL) && (secondary_text_format == NULL)) {
GtkWidget *output_box;
GtkWidget *label;
GtkWidget *scrolled_window;
GtkWidget *text_view;
GtkTextBuffer *text_buffer;
GtkTextIter iter;
GList *scan;
output_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
gtk_box_pack_end (GTK_BOX (gtk_message_dialog_get_message_area (GTK_MESSAGE_DIALOG (dialog))),
output_box, TRUE, TRUE, 0);
label = gtk_label_new_with_mnemonic (_("C_ommand Line Output:"));
gtk_box_pack_start (GTK_BOX (output_box), label, FALSE, FALSE, 0);
scrolled_window = g_object_new (GTK_TYPE_SCROLLED_WINDOW,
"shadow-type", GTK_SHADOW_IN,
"width-request", 450,
"height-request", 200,
NULL);
gtk_box_pack_start (GTK_BOX (output_box), scrolled_window, TRUE, TRUE, 0);
text_view = gtk_text_view_new ();
gtk_label_set_mnemonic_widget (GTK_LABEL (label), text_view);
gtk_container_add (GTK_CONTAINER (scrolled_window), text_view);
text_buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view));
gtk_text_buffer_create_tag (text_buffer, "monospace",
"family", "monospace",
NULL);
gtk_text_buffer_get_iter_at_offset (text_buffer, &iter, 0);
for (scan = row_output; scan; scan = scan->next) {
char *line = scan->data;
char *utf8_line;
gsize bytes_written;
utf8_line = g_locale_to_utf8 (line, -1, NULL, &bytes_written, NULL);
gtk_text_buffer_insert_with_tags_by_name (text_buffer,
&iter,
utf8_line,
bytes_written,
"monospace", NULL);
g_free (utf8_line);
gtk_text_buffer_insert (text_buffer, &iter, "\n", 1);
}
gtk_widget_show_all (output_box);
}
return dialog;
}
