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; }
/* * Modal dialog with yes or no buttons. * Varargs allows the secondary to have printf style varargs. * Returns UIDIALOG_YES (True or 1) or UIDIALOG_NO (False or 0) */ int uidialog_yes_or_no (char *parent_window_name, char *primary_text, char *secondary_text, ... /* varagrs */) { GtkWidget *askw, *parent_win; parent_win = get_widget(parent_window_name); askw = gtk_message_dialog_new(GTK_WINDOW(parent_win), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO, primary_text, NULL); va_list ap; va_start(ap, secondary_text); gtk_message_dialog_format_secondary_markup(GTK_MESSAGE_DIALOG(askw), secondary_text, ap); va_end(ap); gint result = gtk_dialog_run(GTK_DIALOG(askw)); gtk_widget_destroy(askw); switch (result) { case GTK_RESPONSE_YES: return UIDIALOG_YES; default: return UIDIALOG_NO; } return UIDIALOG_NO; }
// NOTE: this is used from 'mscorlib.dll' System.IO.IsolatedStorage/MoonIsolatedStorageFile.cs // NOTE: we let the caller supply the string so i18n can occur in managed land only gboolean isolated_storage_increase_quota_to (const char *primary_text, const char* secondary_text) { #if PAL_GTK_WINDOWING // the dialog is displayed only if the action leading to this call was initiated directly from the user if (!Deployment::GetCurrent ()->GetSurface ()->IsUserInitiatedEvent ()) return false; Surface *surface = Deployment::GetCurrent ()->GetSurface (); GtkWidget *widget = gtk_message_dialog_new_with_markup (NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO, primary_text); gtk_window_set_title (GTK_WINDOW (widget), PACKAGE_STRING); gtk_message_dialog_format_secondary_markup (GTK_MESSAGE_DIALOG (widget), secondary_text); gboolean result = (gtk_dialog_run (GTK_DIALOG (widget)) == GTK_RESPONSE_YES); surface->SetCurrentDeployment (); gtk_widget_destroy (widget); return result; #else return TRUE; #endif }
static void show_error (const gchar *format, ...) { va_list var_args; gchar *s; va_start (var_args, format); s = g_strdup_vprintf (format, var_args); if (have_gtk) { GtkWidget *dialog; dialog = gtk_message_dialog_new_with_markup (NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "<big><b>%s</b></big>", _("An error occurred")); gtk_message_dialog_format_secondary_markup (GTK_MESSAGE_DIALOG (dialog), "%s", s); gtk_window_set_title (GTK_WINDOW (dialog), _("Disk Image Mounter")); gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); } else { g_printerr ("%s\n", s); } g_free (s); va_end (var_args); }
void vino_util_show_error (const gchar *title, const gchar *message, GtkWindow *parent) { GtkWidget *d; gchar *t; if (title) t = g_strdup (title); else t = g_strdup (_("An error has occurred:")); d = gtk_message_dialog_new (parent, GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "%s", t); g_free (t); if (message) gtk_message_dialog_format_secondary_markup (GTK_MESSAGE_DIALOG (d), "%s", message); g_signal_connect_swapped (d, "response", G_CALLBACK (gtk_widget_destroy), d); gtk_widget_show_all (GTK_WIDGET(d)); }
JNIEXPORT void JNICALL Java_org_gnome_gtk_GtkMessageDialog_gtk_1message_1dialog_1format_1secondary_1markup ( JNIEnv* env, jclass cls, jlong _self, jstring _messageFormat ) { GtkMessageDialog* self; const gchar* messageFormat; // convert parameter self self = (GtkMessageDialog*) _self; // convert parameter messageFormat messageFormat = (const gchar*) bindings_java_getString(env, _messageFormat); if (messageFormat == NULL) { return; // Java Exception already thrown } // call function gtk_message_dialog_format_secondary_markup(self, messageFormat, NULL); // cleanup parameter self // cleanup parameter messageFormat bindings_java_releaseString(messageFormat); }
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 void change_filename(GFile* src, const char* dst_name, GtkWidget* parent_window) { char* src_name; GFile* parent; GFile* dst; gboolean res; GError* error = NULL; if (dst_name == NULL) return; src_name = g_file_get_basename(src); if (strcmp(src_name, dst_name) != 0) { parent = g_file_get_parent(src); dst = g_file_get_child(parent, dst_name); res = g_file_move(src, dst, G_FILE_COPY_NOFOLLOW_SYMLINKS, NULL, NULL, NULL, &error); if (!res) { GtkWidget* dialog; char* display_name; gboolean do_free = FALSE;; if (g_utf8_validate(src_name, -1, NULL)) { display_name = src_name; } else { display_name = get_display_name(src_name); do_free = TRUE; } dialog = gtk_message_dialog_new_with_markup(GTK_WINDOW(parent_window), GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, _("<span size=\"larger\" weight=\"bold\">There was an error renaming \"%s\" to \"%s\"</span>"), display_name, dst_name); gtk_message_dialog_format_secondary_markup(GTK_MESSAGE_DIALOG(dialog), "%s", error->message); gtk_dialog_run(GTK_DIALOG(dialog)); gtk_widget_destroy(dialog); g_error_free(error); if (do_free) g_free(display_name); } g_object_unref(G_OBJECT(dst)); } g_free(src_name); }
void no_fileopen_infodisplay(gtk_gui* w, const char* caption) { GtkMessageDialog* dialog = (GtkMessageDialog*) gtk_message_dialog_new (NULL, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_INFO, GTK_BUTTONS_OK, "%s", caption); gtk_message_dialog_format_secondary_markup (dialog, "No file open: Please first select File->Open"); gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (GTK_WIDGET (dialog)); }
//static void on_browse(GtkWidget * widget, gpointer data) void ladish_run_load_project_dialog(ladish_room_proxy_handle room) { GtkFileFilter * filter; GtkWidget * dialog; char * filename; dialog = gtk_file_chooser_dialog_new( _("Load project"), NULL, GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); gtk_file_chooser_set_create_folders(GTK_FILE_CHOOSER(dialog), FALSE); filter = gtk_file_filter_new(); gtk_file_filter_add_custom(filter, GTK_FILE_FILTER_FILENAME, reject_filter, dialog, NULL); /* reject all files */ gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filter); //g_signal_connect(G_OBJECT(dialog), "selection-changed", G_CALLBACK(on_dir_select), dialog); g_signal_connect(G_OBJECT(dialog), "current-folder-changed", G_CALLBACK(dir_changed), dialog); loop: if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) { filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)); if (!is_project_dir(filename)) { GtkWidget * dialog; dialog = get_gtk_builder_widget("error_dialog"); gtk_message_dialog_set_markup(GTK_MESSAGE_DIALOG(dialog), _("<b><big>Not a project dir</big></b>")); gtk_message_dialog_format_secondary_markup(GTK_MESSAGE_DIALOG(dialog), "%s", filename); gtk_widget_show(dialog); gtk_dialog_run(GTK_DIALOG(dialog)); gtk_widget_hide(dialog); goto loop; } //gtk_entry_set_text(GTK_ENTRY(get_gtk_builder_widget("load_project_path_entry")), filename); log_info("Loading project from '%s'", filename); if (!ladish_room_proxy_load_project(room, filename)) { log_error("ladish_room_proxy_load_project() failed."); } g_free(filename); //gtk_widget_activate(gtk_dialog_get_widget_for_response(GTK_DIALOG(data), GTK_RESPONSE_OK)); } gtk_widget_destroy(dialog); return; }
static void gs_page_needs_user_action (GsPageHelper *helper, AsScreenshot *ss) { GtkWidget *content_area; GtkWidget *dialog; GtkWidget *ssimg; g_autofree gchar *escaped = NULL; GsPagePrivate *priv = gs_page_get_instance_private (helper->page); dialog = gtk_message_dialog_new (gs_shell_get_window (priv->shell), GTK_DIALOG_MODAL | GTK_DIALOG_USE_HEADER_BAR, GTK_MESSAGE_INFO, GTK_BUTTONS_CANCEL, /* TRANSLATORS: this is a prompt message, and * '%s' is an application summary, e.g. 'GNOME Clocks' */ _("Prepare %s"), gs_app_get_name (helper->app)); escaped = g_markup_escape_text (as_screenshot_get_caption (ss, NULL), -1); gtk_message_dialog_format_secondary_markup (GTK_MESSAGE_DIALOG (dialog), "%s", escaped); /* this will be enabled when the device is in the right mode */ helper->button_install = gtk_dialog_add_button (GTK_DIALOG (dialog), /* TRANSLATORS: update the fw */ _("Install"), GTK_RESPONSE_OK); helper->notify_quirk_id = g_signal_connect (helper->app, "notify::quirk", G_CALLBACK (gs_page_notify_quirk_cb), helper); gtk_widget_set_sensitive (helper->button_install, FALSE); /* load screenshot */ helper->soup_session = soup_session_new_with_options (SOUP_SESSION_USER_AGENT, gs_user_agent (), NULL); ssimg = gs_screenshot_image_new (helper->soup_session); gs_screenshot_image_set_screenshot (GS_SCREENSHOT_IMAGE (ssimg), ss); gs_screenshot_image_set_size (GS_SCREENSHOT_IMAGE (ssimg), 400, 225); gs_screenshot_image_load_async (GS_SCREENSHOT_IMAGE (ssimg), helper->cancellable); gtk_widget_set_margin_start (ssimg, 24); gtk_widget_set_margin_end (ssimg, 24); content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog)); gtk_container_add (GTK_CONTAINER (content_area), ssimg); gtk_container_child_set (GTK_CONTAINER (content_area), ssimg, "pack-type", GTK_PACK_END, NULL); /* handle this async */ g_signal_connect (dialog, "response", G_CALLBACK (gs_page_update_app_response_cb), helper); gs_shell_modal_dialog_present (priv->shell, GTK_DIALOG (dialog)); }
static void unmount_mount_callback (GObject *source_object, GAsyncResult *res, gpointer user_data) { GError *error; char *primary; gboolean unmounted; gboolean should_eject; GtkWidget *dialog; should_eject = user_data != NULL; error = NULL; if (should_eject) { unmounted = g_mount_eject_with_operation_finish (G_MOUNT (source_object), res, &error); } else { unmounted = g_mount_unmount_with_operation_finish (G_MOUNT (source_object), res, &error); } if (! unmounted) { if (error->code != G_IO_ERROR_FAILED_HANDLED) { if (should_eject) { primary = g_strdup_printf (_("Unable to eject %p"), source_object); } else { primary = g_strdup_printf (_("Unable to unmount %p"), source_object); } dialog = gtk_message_dialog_new (NULL, 0, GTK_MESSAGE_INFO, GTK_BUTTONS_OK, "%s", primary); gtk_message_dialog_format_secondary_markup (GTK_MESSAGE_DIALOG (dialog), "%s", error->message); gtk_widget_show (GTK_WIDGET (dialog)); g_signal_connect (dialog, "response", G_CALLBACK (gtk_widget_destroy), NULL); g_free (primary); } } if (error != NULL) { g_error_free (error); } }
static void warn_if_no_roms (void) { const gchar *sql = SQL_COUNT_ROMS; GtkWidget *dialog; gchar **result; glong n_roms; GError *error = NULL; if (!gva_db_get_table (sql, &result, NULL, NULL, &error)) { gva_error_handle (&error); return; } errno = 0; g_return_if_fail (g_strv_length (result) > 1); n_roms = strtol (result[1], NULL, 10); g_strfreev (result); if (errno != 0) { g_warning ("%s", g_strerror (errno)); return; } if (n_roms > 0) return; dialog = gtk_message_dialog_new_with_markup ( GTK_WINDOW (GVA_WIDGET_MAIN_WINDOW), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_WARNING, GTK_BUTTONS_CLOSE, "<big><b>%s</b></big>", _("No ROM files found")); gtk_message_dialog_format_secondary_markup ( GTK_MESSAGE_DIALOG (dialog), _("GNOME Video Arcade was unable to locate any ROM files. " "It could be that MAME is misconfigured or that no ROM " "files are installed. Click <b>Help</b> for more details " "and troubleshooting tips.")); gtk_dialog_add_button ( GTK_DIALOG (dialog), GTK_STOCK_HELP, GTK_RESPONSE_HELP); if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_HELP) gva_help_display (GTK_WINDOW (dialog), "troubleshooting"); gtk_widget_destroy (dialog); }
/* for when the vte cannot be located */ static void show_error_message(void) { GtkWidget *dlg = gtk_message_dialog_new(NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "%s %s", ST_PLUGIN_NAME, _("Plugin")); gtk_message_dialog_format_secondary_markup(GTK_MESSAGE_DIALOG(dlg), "%s", _("There is currently no terminal loaded in Geany. Enable the terminal " "in Geany's prefrences dialog and restart Geany to use the plugin " "or disable the plugin to stop seeing this error message.")); gtk_dialog_run(GTK_DIALOG(dlg)); gtk_widget_destroy(dlg); }
static void confirm_dialog (DBusGProxy *adapter, DBusGProxy *device, const char *name, const char *long_name, const char *value, DBusGMethodInvocation *context) { GtkWidget *dialog; GtkBuilder *xml; char *str; input_data *input; input = g_new0 (input_data, 1); input->path = g_strdup (dbus_g_proxy_get_path(adapter)); input->device = g_object_ref (device); input->context = context; xml = gtk_builder_new (); if (gtk_builder_add_from_file (xml, "confirm-dialogue.ui", NULL) == 0) gtk_builder_add_from_file (xml, PKGDATADIR "/confirm-dialogue.ui", NULL); dialog = GTK_WIDGET (gtk_builder_get_object (xml, "dialog")); gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER); if (notification_supports_actions () != FALSE) gtk_window_set_keep_above (GTK_WINDOW (dialog), TRUE); else gtk_window_set_focus_on_map (GTK_WINDOW (dialog), FALSE); gtk_window_set_urgency_hint (GTK_WINDOW (dialog), TRUE); input->dialog = dialog; str = g_strdup_printf (_("Device '%s' wants to pair with this computer"), name); g_object_set (G_OBJECT (dialog), "text", str, NULL); g_free (str); str = g_strdup_printf ("<b>%s</b>", value); gtk_message_dialog_format_secondary_markup (GTK_MESSAGE_DIALOG (dialog), _("Please confirm whether the PIN '%s' matches the one on device %s."), str, long_name); g_free (str); input_list = g_list_append (input_list, input); g_signal_connect (G_OBJECT (dialog), "response", G_CALLBACK (confirm_callback), input); enable_blinking (); }
GtkWidget * glide_gtk_util_show_error_dialog (const gchar *text, const gchar *secondary) { GtkWidget *d = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, text, NULL); gtk_message_dialog_format_secondary_markup (GTK_MESSAGE_DIALOG (d), secondary, NULL); gtk_widget_show (d); g_signal_connect (d, "response", G_CALLBACK (glide_error_response_callback), NULL); return d; }
static void show_error_message (GtkWindow *parent, gchar *primary_text, gchar *secondary_text) { GtkWidget *dialog; dialog = gtk_message_dialog_new (parent, GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "%s", primary_text); gtk_message_dialog_format_secondary_markup (GTK_MESSAGE_DIALOG (dialog), "%s", secondary_text); gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); }
static void ask_show_ui (DonnaTaskHelper *th, struct ask *ask) { GtkWidget *w; guint i; gint r; ask->th = th; w = gtk_message_dialog_new (NULL, 0, GTK_MESSAGE_QUESTION, GTK_BUTTONS_NONE, "%s", ask->question); if (ask->details_markup) gtk_message_dialog_format_secondary_markup ((GtkMessageDialog *) w, "%s", ask->details); else gtk_message_dialog_format_secondary_text ((GtkMessageDialog *) w, "%s", ask->details); for (i = 0, r = 1; i < ask->buttons->len; i += 2, ++r) { GtkButton *btn; btn = (GtkButton *) gtk_button_new_with_label (ask->buttons->pdata[i]); if (ask->buttons->pdata[i + 1]) { GdkPixbuf *pb; pb = gtk_icon_theme_load_icon (gtk_icon_theme_get_default (), ask->buttons->pdata[i + 1], /*FIXME*/16, 0, NULL); if (pb) { gtk_button_set_image (btn, gtk_image_new_from_pixbuf (pb)); g_object_unref (pb); } } gtk_widget_set_can_default ((GtkWidget *) btn, TRUE); gtk_dialog_add_action_widget ((GtkDialog *) w, (GtkWidget *) btn, r); } gtk_dialog_set_default_response ((GtkDialog *) w, ask->btn_default); g_signal_connect (w, "delete-event", (GCallback) gtk_true, NULL); g_signal_connect (w, "response", (GCallback) ask_response, ask); ask->widget = w; gtk_widget_show_all (w); }
static void handle_with_cb (GObject *source, GAsyncResult *result, gpointer user_data) { TpChannelDispatchOperation *cdo = TP_CHANNEL_DISPATCH_OPERATION (source); GtkMessageDialog *dialog = GTK_MESSAGE_DIALOG (user_data); GError *error = NULL; if (!tp_channel_dispatch_operation_handle_with_finish (cdo, result, &error)) { g_print ("HandleWith() failed: %s\n", error->message); gtk_message_dialog_format_secondary_markup (dialog, "<b>Error</b>\n\nAsking LibreOffice to accept the session failed: <i>%s</i>", error->message); g_error_free (error); return; } g_print ("HandleWith() succeeded\n"); gtk_widget_destroy (GTK_WIDGET (dialog)); }
/** * Display a dialog presenting the license of a map. * Allow to read the license by launching a web browser. */ void a_dialog_license ( GtkWindow *parent, const gchar *map, const gchar *license, const gchar *url) { GtkWidget *dialog = gtk_message_dialog_new (parent, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_INFO, GTK_BUTTONS_OK, _("The map data is licensed: %s."), license); gtk_message_dialog_format_secondary_markup (GTK_MESSAGE_DIALOG (dialog), _("The data provided by '<b>%s</b>' are licensed under the following license: <b>%s</b>."), map, license); #define RESPONSE_OPEN_LICENSE 600 if (url != NULL) { gtk_dialog_add_button (GTK_DIALOG (dialog), _("Open license"), RESPONSE_OPEN_LICENSE); } gint response; do { response = gtk_dialog_run (GTK_DIALOG (dialog)); if (response == RESPONSE_OPEN_LICENSE) { open_url (parent, url); } } while (response != GTK_RESPONSE_DELETE_EVENT && response != GTK_RESPONSE_OK); gtk_widget_destroy (dialog); }
static void paste(GeanyDocument * doc, const gchar * website) { SoupSession *session; SoupMessage *msg = NULL; gchar *f_content; gchar const *f_type; gchar *f_title; gchar *p_url; gchar *formdata = NULL; gchar *user_agent = NULL; gchar **tokens_array; const gchar *langs_supported_codepad[] = { "C", "C++", "D", "Haskell", "Lua", "OCaml", "PHP", "Perl", "Plain Text", "Python", "Ruby", "Scheme", "Tcl" }; const gchar *langs_supported_dpaste[] = { "Bash", "C", "CSS", "Diff", "Django/Jinja", "HTML", "IRC logs", "JavaScript", "PHP", "Python console session", "Python Traceback", "Python", "Python3", "Restructured Text", "SQL", "Text only" }; gint occ_position; gint i; guint status; gsize f_length; g_return_if_fail(doc && doc->is_valid); f_type = doc->file_type->name; if (doc->file_name == NULL) f_title = document_get_basename_for_display(doc, -1); else f_title = g_path_get_basename(doc->file_name); load_settings(); f_content = get_paste_text(doc, &f_length); if (f_content == NULL || f_content[0] == '\0') { dialogs_show_msgbox(GTK_MESSAGE_ERROR, _("Refusing to create blank paste")); return; } switch (website_selected) { case CODEPAD_ORG: for (i = 0; i < G_N_ELEMENTS(langs_supported_codepad); i++) { if (g_strcmp0(f_type, langs_supported_codepad[i]) == 0) break; else f_type = DEFAULT_TYPE_CODEPAD; } msg = soup_message_new("POST", website); formdata = soup_form_encode("lang", f_type, "code", f_content, "submit", "Submit", NULL); break; case TINYPASTE_COM: msg = soup_message_new("POST", website); formdata = soup_form_encode("paste", f_content, "title", f_title, "is_code", g_strcmp0(f_type, "None") == 0 ? "0" : "1", NULL); break; case DPASTE_DE: for (i = 0; i < G_N_ELEMENTS(langs_supported_dpaste); i++) { if (g_strcmp0(f_type, langs_supported_dpaste[i]) == 0) break; else f_type = DEFAULT_TYPE_DPASTE; } msg = soup_message_new("POST", website); /* apparently dpaste.de detects automatically the syntax of the * pasted code so 'lexer' should be unneeded */ formdata = soup_form_encode("content", f_content, "title", f_title, "lexer", f_type, NULL); break; case SPRUNGE_US: msg = soup_message_new("POST", website); formdata = soup_form_encode("sprunge", f_content, NULL); break; case PASTEBIN_GEANY_ORG: msg = soup_message_new("POST", website); formdata = soup_form_encode("content", f_content, "author", author_name, "title", f_title, "lexer", f_type, NULL); break; } g_free(f_content); user_agent = g_strconcat(PLUGIN_NAME, " ", PLUGIN_VERSION, " / Geany ", GEANY_VERSION, NULL); session = soup_session_async_new_with_options(SOUP_SESSION_USER_AGENT, user_agent, NULL); g_free(user_agent); soup_message_set_request(msg, "application/x-www-form-urlencoded", SOUP_MEMORY_TAKE, formdata, strlen(formdata)); status = soup_session_send_message(session, msg); p_url = g_strdup(msg->response_body->data); g_object_unref(session); g_object_unref(msg); if(status == SOUP_STATUS_OK) { /* * codepad.org doesn't return only the url of the new snippet pasted * but an html page. This minimal parser will get the bare url. */ if (website_selected == CODEPAD_ORG) { tokens_array = g_strsplit(p_url, "<a href=\"", 0); /* cuts the string when it finds the first occurrence of '/' * It shoud work even if codepad would change its url. */ SETPTR(p_url, g_strdup(tokens_array[5])); occ_position = indexof(tokens_array[5], '\"'); g_strfreev(tokens_array); if(occ_position != -1) { p_url[occ_position] = '\0'; } else { dialogs_show_msgbox(GTK_MESSAGE_ERROR, _("Unable to paste the code on codepad.org\n" "Retry or select another pastebin.")); g_free(p_url); return; } } else if(website_selected == TINYPASTE_COM) { /* tinypaste.com returns a XML response which looks * like this: * * <?xml version="1.0" encoding="utf-8"?> * <result> * <response>xxxxx</response> * </result> */ tokens_array = g_strsplit_set(p_url, "<>", 0); SETPTR(p_url, g_strdup_printf("http://%s/%s", websites[TINYPASTE_COM], tokens_array[6])); g_strfreev(tokens_array); } else if(website_selected == DPASTE_DE) { SETPTR(p_url, g_strndup(p_url + 1, strlen(p_url) - 2)); } else if(website_selected == SPRUNGE_US) { /* in order to enable the syntax highlightning on sprunge.us * it is necessary to append at the returned url a question * mark '?' followed by the file type. * * e.g. sprunge.us/xxxx?c */ gchar *ft_tmp = g_ascii_strdown(f_type, -1); g_strstrip(p_url); SETPTR(p_url, g_strdup_printf("%s?%s", p_url, ft_tmp)); g_free(ft_tmp); } if (check_button_is_checked) { utils_open_browser(p_url); } else { GtkWidget *dlg = gtk_message_dialog_new(GTK_WINDOW(geany->main_widgets->window), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_INFO, GTK_BUTTONS_OK, _("Paste Successful")); gtk_message_dialog_format_secondary_markup(GTK_MESSAGE_DIALOG(dlg), _("Your paste can be found here:\n<a href=\"%s\" " "title=\"Click to open the paste in your browser\">%s</a>"), p_url, p_url); gtk_dialog_run(GTK_DIALOG(dlg)); gtk_widget_destroy(dlg); } } else { dialogs_show_msgbox(GTK_MESSAGE_ERROR, _("Unable to paste the code. Check your connection and retry.\n" "Error code: %d\n"), status); } g_free(p_url); }
/** * @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 }
static void task_list_io_xml_save (CTaskList * self, gchar const* path) { GMappedFile* old_version; gchar* xml_path = task_list_io_xml_path (path); FILE* file; /* we don't care if this fails */ old_version = g_mapped_file_new (xml_path, FALSE, NULL); if (old_version) { gchar* backup_path = g_strdup_printf ("%s.%li", xml_path, time (NULL)); g_file_set_contents (backup_path, g_mapped_file_get_contents (old_version), g_mapped_file_get_length (old_version), NULL); g_free (backup_path); g_mapped_file_free (old_version); } file = fopen (xml_path, "w"); if (!file) { int old_errno = errno; GtkWidget* dialog; if (old_errno == ENOENT) { gchar* folder = g_path_get_dirname (xml_path); if (g_mkdir_with_parents (folder, 0755) == 0) { file = fopen (xml_path, "w"); } g_free (folder); if (file) { goto cont; } } /* FIXME: the user should be able to save to a different place */ old_errno = errno; dialog = gtk_message_dialog_new (NULL, /* FIXME: add window */ 0, /* FIXME: make modal */ GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "%s", _("Error saving to file")); gtk_message_dialog_format_secondary_markup (GTK_MESSAGE_DIALOG (dialog), _("Couldn't open file \"%s\" for writing:\n\n" "<span style='italic'>%s</span>"), xml_path, strerror (old_errno)); gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); goto cleanup; } cont: fprintf (file, "<?xml version=\"1.0\" encoding=\"iso-8859-15\"?>\n"); fprintf (file, "<tasks>\n"); dump_nodes (self, file, NULL); fprintf (file, "</tasks>\n"); if (fclose (file) != 0) { /* FIXME: come up with a proper fallback solution */ g_warning ("error closing file: %s", strerror (errno)); } cleanup: g_free (xml_path); }
static gchar* nsgtk_download_dialog_show (const gchar *filename, const gchar *domain, const gchar *size) { enum { GTK_RESPONSE_DOWNLOAD, GTK_RESPONSE_SAVE_AS }; GtkWidget *dialog; char *destination = NULL; gchar *message = g_strdup(messages_get("gtkStartDownload")); gchar *info = g_strdup_printf(messages_get("gtkInfo"), filename, domain, size); dialog = gtk_message_dialog_new_with_markup(nsgtk_download_parent, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_QUESTION, GTK_BUTTONS_NONE, "<span size=\"x-large\" weight=\"ultrabold\">%s</span>" "\n\n<small>%s</small>", message, info); gtk_dialog_add_buttons(GTK_DIALOG(dialog), NSGTK_STOCK_SAVE, GTK_RESPONSE_DOWNLOAD, NSGTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NSGTK_STOCK_SAVE_AS, GTK_RESPONSE_SAVE_AS, NULL); gint result = gtk_dialog_run(GTK_DIALOG(dialog)); gtk_widget_destroy(dialog); g_free(message); g_free(info); switch (result) { case GTK_RESPONSE_SAVE_AS: { dialog = gtk_file_chooser_dialog_new (messages_get("gtkSave"), nsgtk_download_parent, GTK_FILE_CHOOSER_ACTION_SAVE, NSGTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NSGTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL); gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER(dialog), filename); gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER(dialog), nsoption_charp(downloads_directory)); gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER(dialog), nsoption_bool(request_overwrite)); gint result = gtk_dialog_run(GTK_DIALOG(dialog)); if (result == GTK_RESPONSE_ACCEPT) destination = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER(dialog)); gtk_widget_destroy(dialog); break; } case GTK_RESPONSE_DOWNLOAD: { destination = malloc(strlen(nsoption_charp(downloads_directory)) + strlen(filename) + SLEN("/") + 1); if (destination == NULL) { nsgtk_warning(messages_get("NoMemory"), 0); break; } sprintf(destination, "%s/%s", nsoption_charp(downloads_directory), filename); /* Test if file already exists and display overwrite * confirmation if needed */ if (g_file_test(destination, G_FILE_TEST_EXISTS) && nsoption_bool(request_overwrite)) { message = g_strdup_printf(messages_get( "gtkOverwrite"), filename); info = g_strdup_printf(messages_get( "gtkOverwriteInfo"), nsoption_charp(downloads_directory)); dialog = gtk_message_dialog_new_with_markup( nsgtk_download_parent, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_QUESTION, GTK_BUTTONS_CANCEL, "<b>%s</b>",message); gtk_message_dialog_format_secondary_markup( GTK_MESSAGE_DIALOG(dialog), "%s", info); GtkWidget *button = gtk_dialog_add_button( GTK_DIALOG(dialog), "_Replace", GTK_RESPONSE_DOWNLOAD); gtk_button_set_image(GTK_BUTTON(button), nsgtk_image_new_from_stock( NSGTK_STOCK_SAVE, GTK_ICON_SIZE_BUTTON)); gint result = gtk_dialog_run(GTK_DIALOG(dialog)); if (result == GTK_RESPONSE_CANCEL) destination = NULL; gtk_widget_destroy(dialog); g_free(message); g_free(info); } break; } } return destination; }
static VALUE mdiag_format_secondary_markup(VALUE self, VALUE markup) { gtk_message_dialog_format_secondary_markup(_SELF(self), RVAL2CSTR(markup), NULL); return self; }
/** * @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; 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); ////////////// 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_hbox_new(FALSE, 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); gtk_box_pack_end(GTK_BOX(fb_auth_dialog->vbox), hbox, TRUE, TRUE, 0); gtk_widget_show_all(GTK_WIDGET(fb_auth_dialog)); ////////////// wait for the user to entrer 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; }
/** * gs_app_notify_unavailable: **/ GtkResponseType gs_app_notify_unavailable (GsApp *app, GtkWindow *parent) { GsAppLicenceHint hint = GS_APP_LICENCE_FREE; GtkResponseType response; GtkWidget *dialog; const gchar *licence; gboolean already_enabled = FALSE; /* FIXME */ guint i; struct { const gchar *str; GsAppLicenceHint hint; } keywords[] = { { "NonFree", GS_APP_LICENCE_NONFREE }, { "PatentConcern", GS_APP_LICENCE_PATENT_CONCERN }, { "Proprietary", GS_APP_LICENCE_NONFREE }, { NULL, 0 } }; _cleanup_free_ gchar *origin_url = NULL; _cleanup_object_unref_ GSettings *settings = NULL; _cleanup_string_free_ GString *body = NULL; _cleanup_string_free_ GString *title = NULL; /* this is very crude */ licence = gs_app_get_licence (app); if (licence != NULL) { for (i = 0; keywords[i].str != NULL; i++) { if (g_strstr_len (licence, -1, keywords[i].str) != NULL) hint |= keywords[i].hint; } } else { /* use the worst-case assumption */ hint = GS_APP_LICENCE_NONFREE | GS_APP_LICENCE_PATENT_CONCERN; } /* check if the user has already dismissed */ settings = g_settings_new ("org.gnome.software"); if (!g_settings_get_boolean (settings, "prompt-for-nonfree")) return GTK_RESPONSE_OK; title = g_string_new (""); if (already_enabled) { g_string_append_printf (title, "<b>%s</b>", /* TRANSLATORS: window title */ _("Install Third-Party Software?")); } else { g_string_append_printf (title, "<b>%s</b>", /* TRANSLATORS: window title */ _("Enable Third-Party Software Source?")); } dialog = gtk_message_dialog_new (parent, GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_CANCEL, NULL); gtk_message_dialog_set_markup (GTK_MESSAGE_DIALOG (dialog), title->str); /* FIXME: get the URL somehow... */ origin_url = g_strdup_printf ("<a href=\"\">%s>/a>", gs_app_get_origin (app)); body = g_string_new (""); if (hint & GS_APP_LICENCE_NONFREE) { g_string_append_printf (body, /* TRANSLATORS: the replacements are as follows: * 1. Application name, e.g. "Firefox" * 2. Software source name, e.g. fedora-optional */ _("%s is not <a href=\"https://en.wikipedia.org/wiki/Free_and_open-source_software\">" "free and open source software</a>, " "and is provided by “%s”."), gs_app_get_name (app), origin_url); } else { g_string_append_printf (body, /* TRANSLATORS: the replacements are as follows: * 1. Application name, e.g. "Firefox" * 2. Software source name, e.g. fedora-optional */ _("%s is provided by “%s”."), gs_app_get_name (app), origin_url); } /* tell the use what needs to be done */ if (!already_enabled) { g_string_append (body, " "); g_string_append (body, /* TRANSLATORS: a software source is a repo */ _("This software source must be " "enabled to continue installation.")); } /* be aware of patent clauses */ if (hint & GS_APP_LICENCE_PATENT_CONCERN) { g_string_append (body, "\n\n"); if (gs_app_get_id_kind (app) != AS_ID_KIND_CODEC) { g_string_append_printf (body, /* TRANSLATORS: Laws are geographical, urgh... */ _("It may be illegal to install " "or use %s in some countries."), gs_app_get_name (app)); } else { g_string_append (body, /* TRANSLATORS: Laws are geographical, urgh... */ _("It may be illegal to install or use " "this codec in some countries.")); } } gtk_message_dialog_format_secondary_markup (GTK_MESSAGE_DIALOG (dialog), "%s", body->str); /* TRANSLATORS: this is button text to not ask about non-free content again */ if (0) gtk_dialog_add_button (GTK_DIALOG (dialog), _("Don't Warn Again"), GTK_RESPONSE_YES); if (already_enabled) { gtk_dialog_add_button (GTK_DIALOG (dialog), /* TRANSLATORS: button text */ _("Install"), GTK_RESPONSE_OK); } else { gtk_dialog_add_button (GTK_DIALOG (dialog), /* TRANSLATORS: button text */ _("Enable and Install"), GTK_RESPONSE_OK); } response = gtk_dialog_run (GTK_DIALOG (dialog)); if (response == GTK_RESPONSE_YES) { response = GTK_RESPONSE_OK; g_settings_set_boolean (settings, "prompt-for-nonfree", FALSE); } gtk_widget_destroy (dialog); return response; }
void GtkNSSSecurityWarningDialogs::DoDialog (nsIInterfaceRequestor *aContext, const char *aPrefName, GtkMessageType aType, GtkButtonsType aButtons, int aDefaultResponse, const char *aPrimary, const char *aSecondary, const char *aButtonText, PRBool *_retval) { if (_retval) *_retval = PR_FALSE; nsresult rv; PRBool show = PR_TRUE; nsCOMPtr<nsIPrefBranch> prefBranch (do_GetService (NS_PREFSERVICE_CONTRACTID)); if (prefBranch && aPrefName) { rv = prefBranch->GetBoolPref (aPrefName, &show); if (NS_FAILED(rv)) show = PR_TRUE; } char *showOncePref = NULL; PRBool showOnce = PR_FALSE; if (!show && prefBranch && aPrefName) { showOncePref = g_strconcat (aPrefName, ".show_once", NULL); rv = prefBranch->GetBoolPref (showOncePref, &showOnce); if (NS_FAILED (rv)) showOnce = PR_FALSE; } if (!show && !showOnce) { g_free (showOncePref); if (_retval) *_retval = PR_TRUE; return; } AutoJSContextStack stack; rv = stack.Init (); if (NS_FAILED (rv)) return; /* Didn't you know it, mozilla SUCKS! * the "aContext" interface requestor is made from a nsIDOMWindow, * but can only give out a nsIPrompt, from where there's no way to get * the nsIDOMWindow back! * * However GaleonUtils::FindGtkParent falls back to the current active * window so this vageuly works for us at the moment * * https://bugzilla.mozilla.org/show_bug.cgi?id=277587 */ nsCOMPtr<nsIDOMWindow> domWin (do_GetInterface (aContext)); GtkWidget *parent = GaleonUtils::FindGtkParent (domWin); GtkDialogFlags flags = parent ? (GtkDialogFlags)0 : GTK_DIALOG_MODAL; #if GTK_CHECK_VERSION(2,6,0) GtkWidget *dialog = gtk_message_dialog_new (GTK_WINDOW (parent), flags, aType, aButtons, "%s", aPrimary); if (aSecondary) { gtk_message_dialog_format_secondary_markup (GTK_MESSAGE_DIALOG (dialog), "%s", aSecondary); } #else GtkWidget *dialog = hig_alert_new (GTK_WINDOW (parent), flags, aType == GTK_MESSAGE_INFO ? HIG_ALERT_INFORMATION : HIG_ALERT_CONFIRMATION, aPrimary, aSecondary, NULL); if (aButtons == GTK_BUTTONS_OK) { gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_OK, GTK_RESPONSE_OK); } else if (aButtons == GTK_BUTTONS_CANCEL) { gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); } else { g_assert_not_reached(); } #endif if (parent && GTK_WINDOW (parent)->group) { gtk_window_group_add_window (GTK_WINDOW (parent)->group, GTK_WINDOW (dialog)); } if (aButtonText) { gtk_dialog_add_button (GTK_DIALOG (dialog), aButtonText, GTK_RESPONSE_ACCEPT); } gtk_dialog_set_default_response (GTK_DIALOG (dialog), aDefaultResponse); int response = gtk_dialog_run (GTK_DIALOG (dialog)); if (_retval) *_retval = response == GTK_RESPONSE_ACCEPT; if (prefBranch && showOncePref && showOnce) { prefBranch->SetBoolPref (showOncePref, PR_FALSE); } gtk_widget_destroy (dialog); g_free (showOncePref); }
gboolean warn_user_of_impending_doom(FormatDialog* dialog, FormatVolume* target) { GSList* mounted_list = NULL; /* Figure out if we're about to run over any live partitions first */ if(target->volume) { if(libhal_volume_is_mounted(target->volume)) { mounted_list = g_slist_prepend(mounted_list, get_friendly_volume_name(dialog->hal_context, target->volume)); } } else { mounted_list = get_volumes_mounted_on_drive(dialog->hal_context, target->drive); } gchar* message; gchar* name = (target->volume ? get_friendly_volume_name(dialog->hal_context, target->volume) : get_friendly_drive_name(target->drive)); /* Come up with the error message */ if(!mounted_list) { message = g_strdup_printf(_("Formatting will irreversibly destroy all data on %s. " "Are you sure you want to continue?"), name); } else { /* FIXME: There are a ton of malloc's here */ int i; GSList* iter; gchar* tmp_list[65]; /* TODO: It'd be cool if these were hyperlinks that opened nautilus at the mountpoint! */ for(iter = mounted_list, i=0; iter != NULL && i < 64; iter = iter->next, i++) { FormatVolume* current = get_cached_device_from_udi(dialog, (char*)iter->data); g_debug("Mounted: %s", iter->data); if(!current) continue; gchar* mountpoint = libhal_volume_get_mount_point(current->volume); tmp_list[i] = g_strdup_printf( _("%s mounted at %s"), current->friendly_name, mountpoint); } tmp_list[i] = NULL; gchar* vol_list = g_strjoinv("\n", tmp_list); message = g_strdup_printf( _("Formatting will irreversibly destroy all data on %s, " "including these volumes currently in use:" "\n\n%s\n\n" "Are you sure you want to continue?"), name, vol_list); /* Free our stuff */ g_free(vol_list); for(int i=0; i < 64; i++) { if(!tmp_list[i]) break; g_free(tmp_list[i]); } } g_free(name); /* Show the dialog and get the response back */ GtkWidget* messagebox; messagebox = gtk_message_dialog_new(GTK_WINDOW(dialog->toplevel), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_WARNING, GTK_BUTTONS_NONE, _("Formatting will erase data")); gtk_message_dialog_format_secondary_markup(GTK_MESSAGE_DIALOG(messagebox), message); gtk_dialog_add_buttons(GTK_DIALOG(messagebox), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, _("Format device"), GTK_RESPONSE_OK, NULL); int id = gtk_dialog_run(GTK_DIALOG(messagebox)); gtk_widget_destroy(messagebox); return (id == GTK_RESPONSE_OK); }
void gtr_confirm_remove (GtkWindow * parent, TrCore * core, GSList * torrent_ids, gboolean delete_files) { GSList * l; GtkWidget * d; GString * primary_text; GString * secondary_text; struct delete_data * dd; int connected = 0; int incomplete = 0; const int count = g_slist_length (torrent_ids); if (!count) return; dd = g_new0 (struct delete_data, 1); dd->core = core; dd->torrent_ids = torrent_ids; dd->delete_files = delete_files; for (l=torrent_ids; l!=NULL; l=l->next) { const int id = GPOINTER_TO_INT (l->data); tr_torrent * tor = gtr_core_find_torrent (core, id); const tr_stat * stat = tr_torrentStat (tor); if (stat->leftUntilDone) ++incomplete; if (stat->peersConnected) ++connected; } primary_text = g_string_new (NULL); if (!delete_files) { g_string_printf (primary_text, ngettext ("Remove torrent?", "Remove %d torrents?", count), count); } else { g_string_printf (primary_text, ngettext ("Delete this torrent's downloaded files?", "Delete these %d torrents' downloaded files?", count), count); } secondary_text = g_string_new (NULL); if (!incomplete && !connected) { g_string_assign (secondary_text, ngettext ( "Once removed, continuing the transfer will require the torrent file or magnet link.", "Once removed, continuing the transfers will require the torrent files or magnet links.", count)); } else if (count == incomplete) { g_string_assign (secondary_text, ngettext ("This torrent has not finished downloading.", "These torrents have not finished downloading.", count)); } else if (count == connected) { g_string_assign (secondary_text, ngettext ("This torrent is connected to peers.", "These torrents are connected to peers.", count)); } else { if (connected) g_string_append (secondary_text, ngettext ("One of these torrents is connected to peers.", "Some of these torrents are connected to peers.", connected)); if (connected && incomplete) g_string_append (secondary_text, "\n"); if (incomplete) g_string_assign (secondary_text, ngettext ("One of these torrents has not finished downloading.", "Some of these torrents have not finished downloading.", incomplete)); } d = gtk_message_dialog_new_with_markup (parent, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_QUESTION, GTK_BUTTONS_NONE, "<big><b>%s</b></big>", primary_text->str); if (secondary_text->len) gtk_message_dialog_format_secondary_markup (GTK_MESSAGE_DIALOG (d), "%s", secondary_text->str); gtk_dialog_add_buttons (GTK_DIALOG (d), _("_Cancel"), GTK_RESPONSE_CANCEL, (delete_files ? _("_Delete") : _("_Remove")), GTK_RESPONSE_ACCEPT, NULL); gtk_dialog_set_default_response (GTK_DIALOG (d), GTK_RESPONSE_CANCEL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (d), GTK_RESPONSE_ACCEPT, GTK_RESPONSE_CANCEL, -1); g_signal_connect (d, "response", G_CALLBACK (on_remove_dialog_response), dd); gtk_widget_show_all (d); g_string_free (primary_text, TRUE); g_string_free (secondary_text, TRUE); }