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