static void rompath_changed_cb (GFileMonitor *monitor, GFile *file, GFile *other_file, GFileMonitorEvent event_type) { static GtkWidget *dialog = NULL; gint response; if (dialog != NULL) return; /* Filter out events we don't care about. */ switch (event_type) { case G_FILE_MONITOR_EVENT_CHANGED: case G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT: case G_FILE_MONITOR_EVENT_DELETED: case G_FILE_MONITOR_EVENT_CREATED: break; default: return; } dialog = gtk_message_dialog_new_with_markup ( GTK_WINDOW (GVA_WIDGET_MAIN_WINDOW), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_QUESTION, GTK_BUTTONS_NONE, "<big><b>%s</b></big>", _("Changes detected in ROM files")); gtk_message_dialog_format_secondary_text ( GTK_MESSAGE_DIALOG (dialog), _("GNOME Video Arcade has detected changes in your " "ROM files and will need to audit them in order to " "update the game list. However the audit may take " "several minutes to complete. Would you like to " "perform the audit now?\n\nIf you skip the audit now, " "it will be performed automatically the next time you " "start GNOME Video Arcade.")); gtk_dialog_add_buttons ( GTK_DIALOG (dialog), _("_Skip Audit"), GTK_RESPONSE_NO, _("_Audit ROM Files"), GTK_RESPONSE_YES, NULL); response = gtk_dialog_run (GTK_DIALOG (dialog)); /* Don't destroy the dialog just yet. If the file monitor * trips again while we're analyzing ROMs, we want the NULL * check at the top of the function to evaluate TRUE so we * return immediately. */ gtk_widget_hide (dialog); if (response == GTK_RESPONSE_YES) { GError *error = NULL; gva_ui_lock (); gva_main_analyze_roms (&error); gva_error_handle (&error); gva_tree_view_update (&error); gva_error_handle (&error); gva_ui_unlock (); /* Present a helpful dialog if no ROMs were found. */ warn_if_no_roms (); } else { /* Don't bother the user again during this session. */ g_signal_handlers_disconnect_by_func ( monitor, rompath_changed_cb, NULL); } gtk_widget_destroy (dialog); dialog = NULL; }
GtkWidget * do_expander (GtkWidget *do_widget) { GtkWidget *toplevel; GtkWidget *area; GtkWidget *box; 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)); box = gtk_widget_get_parent (area); gtk_container_child_set (GTK_CONTAINER (gtk_widget_get_parent (box)), box, "expand", TRUE, "fill", TRUE, NULL); gtk_container_foreach (GTK_CONTAINER (area), do_not_expand, NULL); 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, TRUE, TRUE, 0); gtk_widget_show_all (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_all (window); else gtk_widget_destroy (window); return window; }
static void export_vpn_to_file_cb (GtkWidget *dialog, gint response, gpointer user_data) { NMConnection *connection = NM_CONNECTION (user_data); char *filename = NULL; GError *error = NULL; NMVpnPluginUiInterface *plugin; NMSettingConnection *s_con = NULL; NMSettingVPN *s_vpn = NULL; const char *service_type; const char *id = NULL; gboolean success = FALSE; if (response != GTK_RESPONSE_ACCEPT) goto out; filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog)); if (!filename) { g_set_error (&error, G_IO_ERROR, G_IO_ERROR_FAILED, "no filename"); goto done; } if (g_file_test (filename, G_FILE_TEST_EXISTS)) { int replace_response; GtkWidget *replace_dialog; char *bname; bname = g_path_get_basename (filename); replace_dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_QUESTION, GTK_BUTTONS_CANCEL, _("A file named \"%s\" already exists."), bname); gtk_dialog_add_buttons (GTK_DIALOG (replace_dialog), _("_Replace"), GTK_RESPONSE_OK, NULL); gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (replace_dialog), _("Do you want to replace %s with the VPN connection you are saving?"), bname); g_free (bname); replace_response = gtk_dialog_run (GTK_DIALOG (replace_dialog)); gtk_widget_destroy (replace_dialog); if (replace_response != GTK_RESPONSE_OK) goto out; } s_con = nm_connection_get_setting_connection (connection); id = s_con ? nm_setting_connection_get_id (s_con) : NULL; if (!id) { g_set_error (&error, G_IO_ERROR, G_IO_ERROR_FAILED, "connection setting invalid"); goto done; } s_vpn = nm_connection_get_setting_vpn (connection); service_type = s_vpn ? nm_setting_vpn_get_service_type (s_vpn) : NULL; if (!service_type) { g_set_error (&error, G_IO_ERROR, G_IO_ERROR_FAILED, "VPN setting invalid"); goto done; } plugin = vpn_get_plugin_by_service (service_type); if (plugin) success = nm_vpn_plugin_ui_interface_export (plugin, filename, connection, &error); done: if (!success) { GtkWidget *err_dialog; char *bname = filename ? g_path_get_basename (filename) : g_strdup ("(none)"); err_dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Cannot export VPN connection")); gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (err_dialog), _("The VPN connection '%s' could not be exported to %s.\n\nError: %s."), id ? id : "(unknown)", bname, error ? error->message : "unknown error"); g_free (bname); g_signal_connect (err_dialog, "delete-event", G_CALLBACK (gtk_widget_destroy), NULL); g_signal_connect (err_dialog, "response", G_CALLBACK (gtk_widget_destroy), NULL); gtk_widget_show_all (err_dialog); gtk_window_present (GTK_WINDOW (err_dialog)); } out: if (error) g_error_free (error); g_object_unref (connection); gtk_widget_hide (dialog); gtk_widget_destroy (dialog); }
/* * Write tag of the ETFile * Return TRUE => OK * FALSE => error */ static gboolean Write_File_Tag (ET_File *ETFile, gboolean hide_msgbox) { GError *error = NULL; const gchar *cur_filename_utf8 = ((File_Name *)ETFile->FileNameCur->data)->value_utf8; gchar *msg = NULL; gchar *basename_utf8; GtkWidget *msgdialog; basename_utf8 = g_path_get_basename(cur_filename_utf8); msg = g_strdup_printf (_("Writing tag of ā%sā"),basename_utf8); et_application_window_status_bar_message (ET_APPLICATION_WINDOW (MainWindow), msg, TRUE); g_free(msg); msg = NULL; if (ET_Save_File_Tag_To_HD (ETFile, &error)) { msg = g_strdup_printf (_("Wrote tag of ā%sā"), basename_utf8); et_application_window_status_bar_message (ET_APPLICATION_WINDOW (MainWindow), msg, TRUE); g_free (msg); g_free (basename_utf8); return TRUE; } Log_Print (LOG_ERROR, "%s", error->message); if (!hide_msgbox) { #ifdef ENABLE_ID3LIB if (g_error_matches (error, ET_ID3_ERROR, ET_ID3_ERROR_BUGGY_ID3LIB)) { msgdialog = gtk_message_dialog_new (GTK_WINDOW (MainWindow), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "%s", _("You have tried to save " "this tag to Unicode but it " "was detected that your " "version of id3lib is buggy")); gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (msgdialog), _("If you reload this " "file, some characters " "in the tag may not be " "displayed correctly. " "Please, apply the " "patch " "src/id3lib/patch_id3lib_3.8.3_UTF16_writing_bug.diff " "to id3lib, which is " "available in the " "EasyTAG package " "sources.\nNote that " "this message will " "appear only " "once.\n\nFile: %s"), basename_utf8); } else #endif { msgdialog = gtk_message_dialog_new (GTK_WINDOW (MainWindow), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, _("Cannot write tag in file ā%sā"), basename_utf8); gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (msgdialog), "%s", error->message); gtk_window_set_title (GTK_WINDOW (msgdialog), _("Tag Write Error")); } gtk_dialog_run(GTK_DIALOG(msgdialog)); gtk_widget_destroy(msgdialog); } g_clear_error (&error); g_free(basename_utf8); return FALSE; }
/** * @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; }
static void do_simple_message_box(ESD_TYPE_E type, gboolean *notagain, const char *secondary_msg, const char *msg_format, va_list ap) { GtkMessageType gtk_message_type; GString *message = g_string_new(""); GtkWidget *msg_dialog; GtkWidget *checkbox = NULL; 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; } } switch (type) { case ESD_TYPE_INFO: gtk_message_type = GTK_MESSAGE_INFO; break; case ESD_TYPE_WARN: gtk_message_type = GTK_MESSAGE_WARNING; break; case ESD_TYPE_ERROR: gtk_message_type = GTK_MESSAGE_ERROR; break; default: g_assert_not_reached(); gtk_message_type = GTK_MESSAGE_INFO; break; } /* Format the message. */ g_string_vprintf(message, msg_format, ap); if (g_utf8_strlen(message->str, message->len) > MAX_MESSAGE_LEN) { const gchar *end = message->str + MAX_MESSAGE_LEN; g_utf8_validate(message->str, MAX_MESSAGE_LEN, &end); g_string_truncate(message, end - message->str); g_string_append(message, UTF8_HORIZONTAL_ELLIPSIS); } msg_dialog = gtk_message_dialog_new(GTK_WINDOW(top_level), (GtkDialogFlags)(GTK_DIALOG_MODAL|GTK_DIALOG_DESTROY_WITH_PARENT), gtk_message_type, GTK_BUTTONS_OK, "%s", message->str); if (secondary_msg != NULL) { g_string_overwrite(message, 0, secondary_msg); if (g_utf8_strlen(message->str, message->len) > MAX_SECONDARY_MESSAGE_LEN) { const gchar *end = message->str + MAX_SECONDARY_MESSAGE_LEN; g_utf8_validate(message->str, MAX_SECONDARY_MESSAGE_LEN, &end); g_string_truncate(message, end - message->str); g_string_append(message, UTF8_HORIZONTAL_ELLIPSIS); } gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(msg_dialog), "%s", message->str); } g_string_free(message, TRUE); 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_dialog_get_content_area(GTK_DIALOG(msg_dialog))), checkbox, TRUE, TRUE, 0); gtk_widget_show(checkbox); } gtk_dialog_run(GTK_DIALOG(msg_dialog)); if (notagain != NULL) { /* * OK, did they check the checkbox? */ *notagain = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(checkbox)); } gtk_widget_destroy(msg_dialog); }
/* * Save_List_Of_Files: Function to save a list of files. * - force_saving_files = TRUE => force saving the file even if it wasn't changed * - force_saving_files = FALSE => force saving only the changed files */ static gint Save_List_Of_Files (GList *etfilelist, gboolean force_saving_files) { EtApplicationWindow *window; gint progress_bar_index; gint saving_answer; gint nb_files_to_save; gint nb_files_changed_by_ext_program; gchar *msg; gchar progress_bar_text[30]; GList *l; ET_File *etfile_save_position = NULL; File_Tag *FileTag; File_Name *FileNameNew; double fraction; GAction *action; GVariant *variant; GtkWidget *widget_focused; GtkTreePath *currentPath = NULL; g_return_val_if_fail (ETCore != NULL, FALSE); window = ET_APPLICATION_WINDOW (MainWindow); /* Save the current position in the list */ etfile_save_position = ETCore->ETFileDisplayed; et_application_window_update_et_file_from_ui (window); /* Save widget that has current focus, to give it again the focus after saving */ widget_focused = gtk_window_get_focus(GTK_WINDOW(MainWindow)); /* Count the number of files to save */ /* Count the number of files changed by an external program */ nb_files_to_save = 0; nb_files_changed_by_ext_program = 0; for (l = etfilelist; l != NULL; l = g_list_next (l)) { GFile *file; GFileInfo *fileinfo; const ET_File *ETFile = (ET_File *)l->data; const File_Tag *file_tag = (File_Tag *)ETFile->FileTag->data; const File_Name *FileName = (File_Name *)ETFile->FileNameNew->data; const gchar *filename_cur = ((File_Name *)ETFile->FileNameCur->data)->value; const gchar *filename_cur_utf8 = ((File_Name *)ETFile->FileNameCur->data)->value_utf8; gchar *basename_cur_utf8 = g_path_get_basename(filename_cur_utf8); // Count only the changed files or all files if force_saving_files==TRUE if (force_saving_files || (FileName && FileName->saved == FALSE) || (file_tag && file_tag->saved == FALSE)) nb_files_to_save++; file = g_file_new_for_path (filename_cur); fileinfo = g_file_query_info (file, G_FILE_ATTRIBUTE_TIME_MODIFIED, G_FILE_QUERY_INFO_NONE, NULL, NULL); g_object_unref (file); if (fileinfo) { if (ETFile->FileModificationTime != g_file_info_get_attribute_uint64 (fileinfo, G_FILE_ATTRIBUTE_TIME_MODIFIED)) { nb_files_changed_by_ext_program++; } g_object_unref (fileinfo); } g_free(basename_cur_utf8); } /* Initialize status bar */ et_application_window_progress_set_fraction (window, 0.0); progress_bar_index = 0; g_snprintf(progress_bar_text, 30, "%d/%d", progress_bar_index, nb_files_to_save); et_application_window_progress_set_text (window, progress_bar_text); /* Set to unsensitive all command buttons (except Quit button) */ et_application_window_disable_command_actions (window); et_application_window_browser_set_sensitive (window, FALSE); et_application_window_tag_area_set_sensitive (window, FALSE); et_application_window_file_area_set_sensitive (window, FALSE); /* Show msgbox (if needed) to ask confirmation ('SF' for Save File) */ SF_HideMsgbox_Write_Tag = FALSE; SF_HideMsgbox_Rename_File = FALSE; Main_Stop_Button_Pressed = FALSE; /* Activate the stop button. */ action = g_action_map_lookup_action (G_ACTION_MAP (MainWindow), "stop"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), FALSE); /* * Check if file was changed by an external program */ if (nb_files_changed_by_ext_program > 0) { // Some files were changed by other program than EasyTAG GtkWidget *msgdialog = NULL; gint response; msgdialog = gtk_message_dialog_new(GTK_WINDOW(MainWindow), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_WARNING, GTK_BUTTONS_NONE, ngettext ("A file was changed by an external program", "%d files were changed by an external program", nb_files_changed_by_ext_program), nb_files_changed_by_ext_program); gtk_dialog_add_buttons (GTK_DIALOG (msgdialog), _("_Discard"), GTK_RESPONSE_NO, _("_Save"), GTK_RESPONSE_YES, NULL); gtk_dialog_set_default_response (GTK_DIALOG (msgdialog), GTK_RESPONSE_YES); gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(msgdialog),"%s",_("Do you want to continue saving the file?")); gtk_window_set_title(GTK_WINDOW(msgdialog),_("Quit")); response = gtk_dialog_run(GTK_DIALOG(msgdialog)); gtk_widget_destroy(msgdialog); switch (response) { case GTK_RESPONSE_YES: break; case GTK_RESPONSE_NO: case GTK_RESPONSE_DELETE_EVENT: /* Skip the following loop. */ Main_Stop_Button_Pressed = TRUE; break; default: g_assert_not_reached (); break; } } for (l = etfilelist; l != NULL && !Main_Stop_Button_Pressed; l = g_list_next (l)) { FileTag = ((ET_File *)l->data)->FileTag->data; FileNameNew = ((ET_File *)l->data)->FileNameNew->data; /* We process only the files changed and not saved, or we force to save all * files if force_saving_files==TRUE */ if ( force_saving_files || FileTag->saved == FALSE || FileNameNew->saved == FALSE ) { /* ET_Display_File_Data_To_UI ((ET_File *)l->data); * Use of 'currentPath' to try to increase speed. Indeed, in many * cases, the next file to select, is the next in the list. */ currentPath = et_application_window_browser_select_file_by_et_file2 (window, (ET_File *)l->data, FALSE, currentPath); fraction = (++progress_bar_index) / (double) nb_files_to_save; et_application_window_progress_set_fraction (window, fraction); g_snprintf(progress_bar_text, 30, "%d/%d", progress_bar_index, nb_files_to_save); et_application_window_progress_set_text (window, progress_bar_text); /* Needed to refresh status bar */ while (gtk_events_pending()) gtk_main_iteration(); // Save tag and rename file saving_answer = Save_File ((ET_File *)l->data, nb_files_to_save > 1 ? TRUE : FALSE, force_saving_files); if (saving_answer == -1) { /* Stop saving files + reinit progress bar */ et_application_window_progress_set_text (window, ""); et_application_window_progress_set_fraction (window, 0.0); et_application_window_status_bar_message (window, _("Saving files was stopped"), TRUE); /* To update state of command buttons */ et_application_window_update_actions (window); et_application_window_browser_set_sensitive (window, TRUE); et_application_window_tag_area_set_sensitive (window, TRUE); et_application_window_file_area_set_sensitive (window, TRUE); if (currentPath) { gtk_tree_path_free (currentPath); } return -1; /* We stop all actions */ } } } if (currentPath) gtk_tree_path_free(currentPath); if (Main_Stop_Button_Pressed) msg = g_strdup (_("Saving files was stopped")); else msg = g_strdup (_("All files have been saved")); Main_Stop_Button_Pressed = FALSE; action = g_action_map_lookup_action (G_ACTION_MAP (MainWindow), "stop"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), FALSE); /* Return to the saved position in the list */ et_application_window_display_et_file (ET_APPLICATION_WINDOW (MainWindow), etfile_save_position); et_application_window_browser_select_file_by_et_file (ET_APPLICATION_WINDOW (MainWindow), etfile_save_position, TRUE); /* FIXME: Find out why this is a special case for the artist/album mode. */ action = g_action_map_lookup_action (G_ACTION_MAP (MainWindow), "file-artist-view"); variant = g_action_get_state (action); if (strcmp (g_variant_get_string (variant, NULL), "artist") == 0) { et_application_window_browser_toggle_display_mode (window); } g_variant_unref (variant); /* To update state of command buttons */ et_application_window_update_actions (ET_APPLICATION_WINDOW (MainWindow)); et_application_window_browser_set_sensitive (window, TRUE); et_application_window_tag_area_set_sensitive (window, TRUE); et_application_window_file_area_set_sensitive (window, TRUE); /* Give again focus to the first entry, else the focus is passed to another */ gtk_widget_grab_focus(GTK_WIDGET(widget_focused)); et_application_window_progress_set_text (window, ""); et_application_window_progress_set_fraction (window, 0.0); et_application_window_status_bar_message (window, msg, TRUE); g_free(msg); et_application_window_browser_refresh_list (window); return TRUE; }
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); }
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; }
static void remove_clicked (CommoditiesDialog *cd) { GNCPriceDB *pdb; GList *node; GList *prices; GList *accounts; gboolean can_delete; gnc_commodity *commodity; GtkWidget *dialog; const gchar *message, *warning; gint response; commodity = gnc_tree_view_commodity_get_selected_commodity (cd->commodity_tree); if (commodity == NULL) return; accounts = gnc_account_get_descendants (gnc_book_get_root_account(cd->book)); can_delete = TRUE; for (node = accounts; node; node = node->next) { Account *account = node->data; if (commodity == xaccAccountGetCommodity (account)) { can_delete = FALSE; break; } } /* FIXME check for transaction references */ if (!can_delete) { const char *message = _("That commodity is currently used by " "at least one of your accounts. You may " "not delete it."); gnc_warning_dialog (cd->dialog, "%s", message); g_list_free (accounts); return; } g_list_free (accounts); pdb = gnc_pricedb_get_db (cd->book); prices = gnc_pricedb_get_prices(pdb, commodity, NULL); if (prices) { message = _("This commodity has price quotes. Are " "you sure you want to delete the selected " "commodity and its price quotes?"); warning = GNC_PREF_WARN_PRICE_COMM_DEL_QUOTES; } else { message = _("Are you sure you want to delete the " "selected commodity?"); warning = GNC_PREF_WARN_PRICE_COMM_DEL; } dialog = gtk_message_dialog_new(GTK_WINDOW(cd->dialog), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_QUESTION, GTK_BUTTONS_NONE, "%s", _("Delete commodity?")); gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog), "%s", message); gtk_dialog_add_buttons(GTK_DIALOG(dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_DELETE, GTK_RESPONSE_OK, (gchar *)NULL); response = gnc_dialog_run(GTK_DIALOG(dialog), warning); gtk_widget_destroy(dialog); if (response == GTK_RESPONSE_OK) { gnc_commodity_table *ct; ct = gnc_commodity_table_get_table (cd->book); for (node = prices; node; node = node->next) gnc_pricedb_remove_price(pdb, node->data); gnc_commodity_table_remove (ct, commodity); gnc_commodity_destroy (commodity); commodity = NULL; } gnc_price_list_destroy(prices); gnc_gui_refresh_all (); }
/** * main: **/ int main (int argc, char **argv) { gboolean ret; const gchar *copyright; const gchar *description; GFile *destination = NULL; GFile *file = NULL; gchar **files = NULL; guint retval = 1; McmProfile *profile = NULL; McmColorspace colorspace; GError *error = NULL; GOptionContext *context; GString *string = NULL; GtkWidget *dialog; GtkResponseType response; GtkWidget *cie_widget = NULL; McmXyz *white = NULL; McmXyz *red = NULL; McmXyz *green = NULL; McmXyz *blue = NULL; const GOptionEntry options[] = { { G_OPTION_REMAINING, '\0', 0, G_OPTION_ARG_FILENAME_ARRAY, &files, /* TRANSLATORS: command line option: a list of catalogs to install */ _("ICC profile to install"), NULL }, { NULL} }; setlocale (LC_ALL, ""); bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR); bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); textdomain (GETTEXT_PACKAGE); gtk_init (&argc, &argv); context = g_option_context_new ("mate-color-manager import program"); g_option_context_add_main_entries (context, options, NULL); g_option_context_add_group (context, egg_debug_get_option_group ()); g_option_context_add_group (context, gtk_get_option_group (TRUE)); g_option_context_parse (context, &argc, &argv, NULL); g_option_context_free (context); /* nothing sent */ if (files == NULL) { /* TRANSLATORS: nothing was specified on the command line */ dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, _("No filename specified")); gtk_window_set_icon_name (GTK_WINDOW (dialog), MCM_STOCK_ICON); gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); goto out; } /* load profile */ profile = mcm_profile_default_new (); file = g_file_new_for_path (files[0]); ret = mcm_profile_parse (profile, file, &error); if (!ret) { /* TRANSLATORS: could not read file */ dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, _("Failed to open ICC profile")); gtk_window_set_icon_name (GTK_WINDOW (dialog), MCM_STOCK_ICON); /* TRANSLATORS: parsing error */ gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), _("Failed to parse file: %s"), error->message); gtk_dialog_run (GTK_DIALOG (dialog)); g_error_free (error); gtk_widget_destroy (dialog); goto out; } /* get data */ description = mcm_profile_get_description (profile); copyright = mcm_profile_get_copyright (profile); colorspace = mcm_profile_get_colorspace (profile); g_object_get (profile, "white", &white, "red", &red, "green", &green, "blue", &blue, NULL); /* use CIE widget */ cie_widget = mcm_cie_widget_new (); gtk_widget_set_size_request (cie_widget, 200, 200); g_object_set (cie_widget, "use-grid", FALSE, "use-whitepoint", FALSE, "white", white, "red", red, "green", green, "blue", blue, NULL); /* check file does't already exist */ destination = mcm_utils_get_profile_destination (file); ret = g_file_query_exists (destination, NULL); if (ret) { /* TRANSLATORS: color profile already been installed */ dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_INFO, GTK_BUTTONS_CLOSE, _("ICC profile already installed")); gtk_window_set_icon_name (GTK_WINDOW (dialog), MCM_STOCK_ICON); gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), "%s\n%s", description, copyright); /* add cie widget */ mcm_import_add_cie_widget (GTK_DIALOG(dialog), cie_widget); gtk_window_set_resizable (GTK_WINDOW (dialog), TRUE); gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); goto out; } /* create message */ string = g_string_new (""); if (description != NULL) { /* TRANSLATORS: message text */ g_string_append_printf (string, _("Import ICC color profile %s?"), description); } else { /* TRANSLATORS: message text */ g_string_append (string, _("Import ICC color profile?")); } /* add copyright */ if (copyright != NULL) g_string_append_printf (string, "\n%s", copyright); /* ask confirmation */ dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_CLOSE, "%s", _("Import ICC profile")); gtk_window_set_icon_name (GTK_WINDOW (dialog), MCM_STOCK_ICON); gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), "%s", string->str); /* TRANSLATORS: button text */ gtk_dialog_add_button (GTK_DIALOG (dialog), _("Install"), GTK_RESPONSE_OK); /* add cie widget */ mcm_import_add_cie_widget (GTK_DIALOG(dialog), cie_widget); /* only show the cie widget if we have RGB data */ if (colorspace != MCM_COLORSPACE_RGB) gtk_widget_hide (cie_widget); gtk_window_set_resizable (GTK_WINDOW (dialog), TRUE); response = gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); /* not the correct response */ if (response != GTK_RESPONSE_OK) goto out; /* copy icc file to users profile path */ ret = mcm_utils_mkdir_and_copy (file, destination, &error); if (!ret) { /* TRANSLATORS: could not read file */ dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, _("Failed to copy file")); gtk_window_set_icon_name (GTK_WINDOW (dialog), MCM_STOCK_ICON); gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), "%s", error->message); gtk_dialog_run (GTK_DIALOG (dialog)); g_error_free (error); gtk_widget_destroy (dialog); goto out; } /* open up the preferences */ ret = g_spawn_command_line_async (BINDIR "/mcm-prefs", &error); if (!ret) { egg_warning ("failed to spawn preferences: %s", error->message); g_error_free (error); goto out; } out: if (file != NULL) g_object_unref (file); if (white != NULL) g_object_unref (white); if (red != NULL) g_object_unref (red); if (green != NULL) g_object_unref (green); if (blue != NULL) g_object_unref (blue); if (string != NULL) g_string_free (string, TRUE); if (profile != NULL) g_object_unref (profile); if (destination != NULL) g_object_unref (destination); g_strfreev (files); return retval; }
static void delete_button_clicked (GtkWidget *button, GtrPreferencesDialog *dlg) { GtkTreeIter iter; GtkTreeModel *model; GtkTreeSelection *selection; gboolean active; GtkWidget *dialog; gchar *markup; model = gtk_tree_view_get_model (GTK_TREE_VIEW (dlg->priv->profile_treeview)); g_return_if_fail (model != NULL); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (dlg->priv->profile_treeview)); if (gtk_tree_selection_get_selected (selection, &model, &iter)) { gtk_tree_model_get (model, &iter, ACTIVE_PROFILE_COLUMN, &active, -1); if (active) { dialog = gtk_message_dialog_new (GTK_WINDOW (dlg), GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, NULL); markup = g_strdup_printf("<span weight=\"bold\" size=\"large\">%s</span>", _("Impossible to remove the active profile")); gtk_message_dialog_set_markup (GTK_MESSAGE_DIALOG (dialog), markup); g_free(markup); gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), _("Another profile should be selected as active before")); gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); } else { dialog = gtk_message_dialog_new (GTK_WINDOW (dlg), GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_NONE, NULL); markup = g_strdup_printf("<span weight=\"bold\" size=\"large\">%s</span>", _("Are you sure you want to delete this profile?")); gtk_message_dialog_set_markup (GTK_MESSAGE_DIALOG (dialog), markup); g_free(markup); gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_DELETE, GTK_RESPONSE_YES); gtk_dialog_run (GTK_DIALOG (dialog)); g_signal_connect (GTK_DIALOG (dialog), "response", G_CALLBACK (delete_confirm_dialog_cb), dlg); } } }
static void _really_move_to_trash (CheeseWindow *cheese_window, GList *files) { GError *error = NULL; GList *l = NULL; GList *d = NULL; gchar *primary, *secondary; GtkWidget *question_dialog; gint response; gint list_length = g_list_length (files); g_print ("received %d items to delete\n", list_length); for (l = files; l != NULL; l = l->next) { if (!g_file_test (g_file_get_path (l->data), G_FILE_TEST_EXISTS)) { g_object_unref (l->data); break; } if (!g_file_trash (l->data, NULL, &error)) { primary = g_strdup (_("Cannot move file to trash, do you want to delete immediately?")); secondary = g_strdup_printf (_("The file \"%s\" cannot be moved to the trash. Details: %s"), g_file_get_basename (l->data), error->message); question_dialog = gtk_message_dialog_new (GTK_WINDOW (cheese_window), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_QUESTION, GTK_BUTTONS_NONE, "%s", primary); gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (question_dialog), "%s", secondary); gtk_dialog_add_button (GTK_DIALOG (question_dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); if (list_length > 1) { /* no need for all those buttons we have a single file to delete */ gtk_dialog_add_button (GTK_DIALOG (question_dialog), CHEESE_BUTTON_SKIP, CHEESE_RESPONSE_SKIP); gtk_dialog_add_button (GTK_DIALOG (question_dialog), CHEESE_BUTTON_SKIP_ALL, CHEESE_RESPONSE_SKIP_ALL); gtk_dialog_add_button (GTK_DIALOG (question_dialog), CHEESE_BUTTON_DELETE_ALL, CHEESE_RESPONSE_DELETE_ALL); } gtk_dialog_add_button (GTK_DIALOG (question_dialog), GTK_STOCK_DELETE, GTK_RESPONSE_ACCEPT); response = gtk_dialog_run (GTK_DIALOG (question_dialog)); gtk_widget_destroy (question_dialog); g_free (primary); g_free (secondary); g_error_free (error); error = NULL; switch (response) { case CHEESE_RESPONSE_DELETE_ALL: /* forward the list to cmd_delete */ _really_delete (cheese_window, l, TRUE); return; case GTK_RESPONSE_ACCEPT: /* create a single file list for cmd_delete */ d = g_list_append (d, g_object_ref (l->data)); _really_delete (cheese_window, d, TRUE); g_list_free (d); break; case CHEESE_RESPONSE_SKIP: /* do nothing, skip to the next item */ break; case CHEESE_RESPONSE_SKIP_ALL: case GTK_RESPONSE_CANCEL: case GTK_RESPONSE_DELETE_EVENT: default: /* cancel the whole delete operation */ return; } } else { cheese_thumb_view_remove_item (cheese_window_get_thumbview (cheese_window), l->data); } g_object_unref (l->data); } }
void gs_offline_updates_show_error (void) { const gchar *title; gboolean show_geeky = FALSE; GtkWidget *dialog; _cleanup_error_free_ GError *error = NULL; _cleanup_object_unref_ PkError *pk_error = NULL; _cleanup_object_unref_ PkResults *results = NULL; _cleanup_string_free_ GString *msg = NULL; results = pk_offline_get_results (NULL); if (results == NULL) return; pk_error = pk_results_get_error_code (results); if (pk_error == NULL) return; /* can this happen in reality? */ if (pk_results_get_exit_code (results) == PK_EXIT_ENUM_SUCCESS) return; /* TRANSLATORS: this is when the offline update failed */ title = _("Failed To Update"); msg = g_string_new (""); switch (pk_error_get_code (pk_error)) { case PK_ERROR_ENUM_UNFINISHED_TRANSACTION: /* TRANSLATORS: the transaction could not be completed * as a previous transaction was unfinished */ g_string_append (msg, _("A previous update was unfinished.")); show_geeky = TRUE; break; case PK_ERROR_ENUM_PACKAGE_DOWNLOAD_FAILED: case PK_ERROR_ENUM_NO_CACHE: case PK_ERROR_ENUM_NO_NETWORK: case PK_ERROR_ENUM_NO_MORE_MIRRORS_TO_TRY: case PK_ERROR_ENUM_CANNOT_FETCH_SOURCES: /* TRANSLATORS: the package manager needed to download * something with no network available */ g_string_append (msg, _("Network access was required but not available.")); break; case PK_ERROR_ENUM_BAD_GPG_SIGNATURE: case PK_ERROR_ENUM_CANNOT_UPDATE_REPO_UNSIGNED: case PK_ERROR_ENUM_GPG_FAILURE: case PK_ERROR_ENUM_MISSING_GPG_SIGNATURE: case PK_ERROR_ENUM_PACKAGE_CORRUPT: /* TRANSLATORS: if the package is not signed correctly * */ g_string_append (msg, _("An update was not signed in the correct way.")); show_geeky = TRUE; break; case PK_ERROR_ENUM_DEP_RESOLUTION_FAILED: case PK_ERROR_ENUM_FILE_CONFLICTS: case PK_ERROR_ENUM_INCOMPATIBLE_ARCHITECTURE: case PK_ERROR_ENUM_PACKAGE_CONFLICTS: /* TRANSLATORS: the transaction failed in a way the user * probably cannot comprehend. Package management systems * really are teh suck.*/ g_string_append (msg, _("The update could not be completed.")); show_geeky = TRUE; break; case PK_ERROR_ENUM_TRANSACTION_CANCELLED: /* TRANSLATORS: the user aborted the update manually */ g_string_append (msg, _("The update was cancelled.")); break; case PK_ERROR_ENUM_NO_PACKAGES_TO_UPDATE: case PK_ERROR_ENUM_UPDATE_NOT_FOUND: /* TRANSLATORS: the user must have updated manually after * the updates were prepared */ g_string_append (msg, _("An offline update was requested but no packages required updating.")); break; case PK_ERROR_ENUM_NO_SPACE_ON_DEVICE: /* TRANSLATORS: we ran out of disk space */ g_string_append (msg, _("No space was left on the drive.")); break; case PK_ERROR_ENUM_PACKAGE_FAILED_TO_BUILD: case PK_ERROR_ENUM_PACKAGE_FAILED_TO_INSTALL: case PK_ERROR_ENUM_PACKAGE_FAILED_TO_REMOVE: /* TRANSLATORS: the update process failed in a general * way, usually this message will come from source distros * like gentoo */ g_string_append (msg, _("An update failed to install correctly.")); show_geeky = TRUE; break; default: /* TRANSLATORS: We didn't handle the error type */ g_string_append (msg, _("The offline update failed in an unexpected way.")); show_geeky = TRUE; break; } if (show_geeky) { g_string_append_printf (msg, "\n%s\n\n%s", /* TRANSLATORS: these are geeky messages from the * package manager no mortal is supposed to understand, * but google might know what they mean */ _("Detailed errors from the package manager follow:"), pk_error_get_details (pk_error)); } dialog = gtk_message_dialog_new (NULL, 0, GTK_MESSAGE_INFO, GTK_BUTTONS_CLOSE, "%s", title); gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), "%s", msg->str); g_signal_connect_swapped (dialog, "response", G_CALLBACK (gtk_widget_destroy), dialog); gtk_widget_show (dialog); if (!pk_offline_clear_results (NULL, &error)) { g_warning ("Failure clearing offline update message: %s", error->message); } }
/** * @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 }
void clock_utils_display_help (GtkWidget *widget, const char *doc_id, const char *link_id) { GError *error = NULL; char *uri; if (link_id) uri = g_strdup_printf ("help:%s?%s", doc_id, link_id); else uri = g_strdup_printf ("help:%s", doc_id); gtk_show_uri (gtk_widget_get_screen (widget), uri, gtk_get_current_event_time (), &error); g_free (uri); if (error && g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) g_error_free (error); else if (error) { GtkWidget *parent; GtkWidget *dialog; char *primary; if (GTK_IS_WINDOW (widget)) parent = widget; else parent = NULL; primary = g_markup_printf_escaped ( _("Could not display help document '%s'"), doc_id); dialog = gtk_message_dialog_new ( parent ? GTK_WINDOW (parent) : NULL, GTK_DIALOG_MODAL|GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "%s", primary); gtk_message_dialog_format_secondary_text ( GTK_MESSAGE_DIALOG (dialog), "%s", error->message); g_error_free (error); g_free (primary); g_signal_connect (dialog, "response", G_CALLBACK (gtk_widget_destroy), NULL); gtk_window_set_icon_name (GTK_WINDOW (dialog), CLOCK_ICON); gtk_window_set_screen (GTK_WINDOW (dialog), gtk_widget_get_screen (widget)); if (parent == NULL) { /* we have no parent window */ gtk_window_set_skip_taskbar_hint (GTK_WINDOW (dialog), FALSE); gtk_window_set_title (GTK_WINDOW (dialog), _("Error displaying help document")); } gtk_widget_show (dialog); } }
static int passphrase_dialog(char *message) { const char *failed; char *passphrase, *local; int result, grab_tries, grab_server, grab_pointer; GtkWidget *dialog, *entry; GdkGrabStatus status; grab_server = (getenv("GNOME_SSH_ASKPASS_GRAB_SERVER") != NULL); grab_pointer = (getenv("GNOME_SSH_ASKPASS_GRAB_POINTER") != NULL); grab_tries = 0; dialog = gtk_message_dialog_new(NULL, 0, GTK_MESSAGE_QUESTION, GTK_BUTTONS_OK_CANCEL, "%s", message); entry = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), entry, FALSE, FALSE, 0); gtk_entry_set_visibility(GTK_ENTRY(entry), FALSE); gtk_widget_grab_focus(entry); gtk_widget_show(entry); gtk_window_set_title(GTK_WINDOW(dialog), "OpenSSH"); gtk_window_set_position (GTK_WINDOW(dialog), GTK_WIN_POS_CENTER); gtk_window_set_keep_above(GTK_WINDOW(dialog), TRUE); gtk_label_set_line_wrap(GTK_LABEL((GTK_MESSAGE_DIALOG(dialog))->label), TRUE); /* Make <enter> close dialog */ gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK); g_signal_connect(G_OBJECT(entry), "activate", G_CALLBACK(ok_dialog), dialog); gtk_window_set_keep_above(GTK_WINDOW(dialog), TRUE); /* Grab focus */ gtk_widget_show_now(dialog); if (grab_pointer) { for(;;) { status = gdk_pointer_grab( (GTK_WIDGET(dialog))->window, TRUE, 0, NULL, NULL, GDK_CURRENT_TIME); if (status == GDK_GRAB_SUCCESS) break; usleep(GRAB_WAIT * 1000); if (++grab_tries > GRAB_TRIES) { failed = "mouse"; goto nograb; } } } for(;;) { status = gdk_keyboard_grab((GTK_WIDGET(dialog))->window, FALSE, GDK_CURRENT_TIME); if (status == GDK_GRAB_SUCCESS) break; usleep(GRAB_WAIT * 1000); if (++grab_tries > GRAB_TRIES) { failed = "keyboard"; goto nograbkb; } } if (grab_server) { gdk_x11_grab_server(); } result = gtk_dialog_run(GTK_DIALOG(dialog)); /* Ungrab */ if (grab_server) XUngrabServer(GDK_DISPLAY()); if (grab_pointer) gdk_pointer_ungrab(GDK_CURRENT_TIME); gdk_keyboard_ungrab(GDK_CURRENT_TIME); gdk_flush(); /* Report passphrase if user selected OK */ passphrase = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry))); if (result == GTK_RESPONSE_OK) { local = g_locale_from_utf8(passphrase, strlen(passphrase), NULL, NULL, NULL); if (local != NULL) { puts(local); memset(local, '\0', strlen(local)); g_free(local); } else { puts(passphrase); } } /* Zero passphrase in memory */ memset(passphrase, '\b', strlen(passphrase)); gtk_entry_set_text(GTK_ENTRY(entry), passphrase); memset(passphrase, '\0', strlen(passphrase)); g_free(passphrase); gtk_widget_destroy(dialog); return (result == GTK_RESPONSE_OK ? 0 : -1); /* At least one grab failed - ungrab what we got, and report the failure to the user. Note that XGrabServer() cannot fail. */ nograbkb: gdk_pointer_ungrab(GDK_CURRENT_TIME); nograb: if (grab_server) XUngrabServer(GDK_DISPLAY()); gtk_widget_destroy(dialog); report_failed_grab(failed); return (-1); }
static TrayData * create_tray_on_screen (GdkScreen *screen, gboolean force) { GtkWidget *window, *hbox, *vbox, *button, *combo, *label; TrayData *data; n_windows++; if (!force && na_tray_manager_check_running (screen)) { GtkWidget *dialog; dialog = gtk_message_dialog_new (NULL, 0, GTK_MESSAGE_WARNING, GTK_BUTTONS_YES_NO, "Override tray manager?"); gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), "There is already a tray manager running on screen %d.", gdk_screen_get_number (screen)); gtk_window_set_screen (GTK_WINDOW (dialog), screen); g_signal_connect (dialog, "response", G_CALLBACK (warning_dialog_response_cb), screen); gtk_window_present (GTK_WINDOW (dialog)); g_object_weak_ref (G_OBJECT (dialog), (GWeakNotify) maybe_quit, NULL); return NULL; } data = g_new0 (TrayData, 1); data->screen = screen; data->screen_num = gdk_screen_get_number (screen); data->window = window = gtk_window_new (GTK_WINDOW_TOPLEVEL); g_object_weak_ref (G_OBJECT (window), (GWeakNotify) maybe_quit, NULL); vbox = gtk_vbox_new (FALSE, 6); gtk_container_add (GTK_CONTAINER (window), vbox); button = gtk_button_new_with_mnemonic ("_Add another tray"); g_signal_connect (button, "clicked", G_CALLBACK (add_tray_cb), data); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); hbox = gtk_hbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); label = gtk_label_new_with_mnemonic ("_Orientation:"); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); combo = gtk_combo_box_new_text (); gtk_combo_box_append_text (GTK_COMBO_BOX (combo), "Horizontal"); gtk_combo_box_append_text (GTK_COMBO_BOX (combo), "Vertical"); g_signal_connect (combo, "changed", G_CALLBACK (orientation_changed_cb), data); gtk_box_pack_start (GTK_BOX (hbox), combo, FALSE, FALSE, 0); label = gtk_label_new (NULL); data->count_label = GTK_LABEL (label); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); data->tray = na_tray_new_for_screen (screen, GTK_ORIENTATION_HORIZONTAL); gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (data->tray), TRUE, TRUE, 0); data->box = gtk_bin_get_child (GTK_BIN (gtk_bin_get_child (GTK_BIN (data->tray)))); g_signal_connect_after (data->box, "add", G_CALLBACK (tray_added_cb), data); g_signal_connect_after (data->box, "remove", G_CALLBACK (tray_removed_cb), data); gtk_combo_box_set_active (GTK_COMBO_BOX (combo), 0); gtk_window_set_screen (GTK_WINDOW (window), screen); gtk_window_set_default_size (GTK_WINDOW (window), -1, 200); /* gtk_window_set_resizable (GTK_WINDOW (window), FALSE); */ gtk_widget_show_all (window); update_child_count (data); return data; }
/** * Display a tip. * * \param force Forcefully display the tip even if show_tip option * has been disabled. */ void display_tip ( gboolean force ) { GtkWidget * checkbox; GtkWidget * dialog = NULL; GtkWidget *btn_back, *btn_forward, *btn_close; gchar *tmpstr; if ( !force && !conf.show_tip ) return; conf.last_tip = CLAMP ( conf.last_tip+1, 0, sizeof(tips)/sizeof(gpointer)-1); dialog = dialogue_special_no_run ( GTK_MESSAGE_INFO, GTK_BUTTONS_NONE, make_hint ( _("Did you know that..."), /* We use the Grisbi-tips catalog */ g_dgettext(NULL, tips[conf.last_tip]) ) ); gtk_window_set_modal ( GTK_WINDOW ( dialog ), FALSE ); checkbox = gsb_automem_checkbutton_new ( _("Display tips at next start"), &(conf.show_tip), NULL, NULL ); gtk_box_pack_start ( GTK_BOX ( GTK_DIALOG(dialog) -> vbox ), checkbox, FALSE, FALSE, 6 ); gtk_widget_show ( checkbox ); btn_back = gtk_dialog_add_button (GTK_DIALOG(dialog), GTK_STOCK_GO_BACK, 1); btn_forward = gtk_dialog_add_button (GTK_DIALOG(dialog), GTK_STOCK_GO_FORWARD, 2); btn_close = gtk_dialog_add_button (GTK_DIALOG(dialog), GTK_STOCK_CLOSE, 3); /* gtk_widget_set_size_request ( dialog, 450, -1 ); */ /* We iterate as user can select several tips. */ while ( TRUE ) { if ( conf.last_tip == sizeof(tips)/sizeof(gpointer)-1) gtk_widget_set_sensitive (btn_forward, FALSE); if ( conf.last_tip == 0) gtk_widget_set_sensitive (btn_back, FALSE); switch ( gtk_dialog_run ( GTK_DIALOG(dialog) ) ) { case 1: if ( conf.last_tip > 0 ) conf.last_tip--; gtk_widget_set_sensitive (btn_forward, TRUE); tmpstr = g_strconcat ( make_pango_attribut ( "size=\"larger\" weight=\"bold\"", _("Did you know that...") ), "\n\n", g_dgettext (NULL, tips[conf.last_tip] ), NULL ); gtk_label_set_markup ( GTK_LABEL ( GTK_MESSAGE_DIALOG(dialog) -> label ), tmpstr ); g_free ( tmpstr ); break; case 2: if ( conf.last_tip < sizeof(tips)/sizeof(gpointer)-1) conf.last_tip++; tmpstr = g_strconcat ( make_pango_attribut ( "size=\"larger\" weight=\"bold\"", _("Did you know that...") ), "\n\n", g_dgettext (NULL, tips[conf.last_tip] ), NULL ); gtk_label_set_markup ( GTK_LABEL ( GTK_MESSAGE_DIALOG(dialog) -> label ), tmpstr ); g_free ( tmpstr ); gtk_widget_set_sensitive (btn_back, TRUE); break; default: gtk_widget_destroy ( dialog ); return; } } }
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); }
/* * 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; }
static void write_button_clicked (EtPlaylistDialog *self) { EtPlaylistDialogPrivate *priv; gchar *playlist_name = NULL; gchar *playlist_path_utf8; // Path gchar *playlist_basename_utf8; // Filename gchar *playlist_name_utf8; // Path + filename gchar *temp; GtkWidget *msgdialog; priv = et_playlist_dialog_get_instance_private (self); /* Check if playlist name was filled. */ if (g_settings_get_boolean (MainSettings, "playlist-use-mask") && *(gtk_entry_get_text (GTK_ENTRY (priv->name_mask_entry))) == '\0') { /* TODO: Can this happen? */ g_settings_set_boolean (MainSettings, "playlist-use-mask", FALSE); } // Path of the playlist file (may be truncated later if PLAYLIST_CREATE_IN_PARENT_DIR is TRUE) temp = g_file_get_path (et_application_window_get_current_path (ET_APPLICATION_WINDOW (MainWindow))); playlist_path_utf8 = g_filename_display_name (temp); g_free (temp); /* Build the playlist filename. */ if (g_settings_get_boolean (MainSettings, "playlist-use-mask")) { EtConvertSpaces convert_mode; if (!ETCore->ETFileList) return; playlist_name = g_settings_get_string (MainSettings, "playlist-filename-mask"); /* Generate filename from tag of the current selected file (FIXME). */ temp = filename_from_display (playlist_name); g_free (playlist_name); playlist_basename_utf8 = et_scan_generate_new_filename_from_mask (ETCore->ETFileDisplayed, temp, FALSE); g_free (temp); /* Replace Characters (with scanner). */ convert_mode = g_settings_get_enum (MainSettings, "rename-convert-spaces"); switch (convert_mode) { case ET_CONVERT_SPACES_SPACES: Scan_Convert_Underscore_Into_Space (playlist_basename_utf8); Scan_Convert_P20_Into_Space (playlist_basename_utf8); break; case ET_CONVERT_SPACES_UNDERSCORES: Scan_Convert_Space_Into_Underscore (playlist_basename_utf8); break; case ET_CONVERT_SPACES_REMOVE: Scan_Remove_Spaces (playlist_basename_utf8); break; /* FIXME: Check that this is intended. */ case ET_CONVERT_SPACES_NO_CHANGE: default: g_assert_not_reached (); break; } }else // PLAYLIST_USE_DIR_NAME { if ( strcmp(playlist_path_utf8,G_DIR_SEPARATOR_S)==0 ) { playlist_basename_utf8 = g_strdup("playlist"); }else { gchar *tmp_string = g_strdup(playlist_path_utf8); // Remove last '/' if (tmp_string[strlen(tmp_string)-1]==G_DIR_SEPARATOR) tmp_string[strlen(tmp_string)-1] = '\0'; // Get directory name temp = g_path_get_basename(tmp_string); playlist_basename_utf8 = g_strdup(temp); g_free(tmp_string); g_free(temp); } } /* Must be placed after "Build the playlist filename", as we can truncate * the path! */ if (g_settings_get_boolean (MainSettings, "playlist-parent-directory")) { if ( (strcmp(playlist_path_utf8,G_DIR_SEPARATOR_S) != 0) ) { gchar *tmp; // Remove last '/' if (playlist_path_utf8[strlen(playlist_path_utf8)-1]==G_DIR_SEPARATOR) playlist_path_utf8[strlen(playlist_path_utf8)-1] = '\0'; // Get parent directory if ( (tmp=strrchr(playlist_path_utf8,G_DIR_SEPARATOR)) != NULL ) *(tmp + 1) = '\0'; } } // Generate path + filename of playlist if (playlist_path_utf8[strlen(playlist_path_utf8)-1]==G_DIR_SEPARATOR) playlist_name_utf8 = g_strconcat(playlist_path_utf8,playlist_basename_utf8,".m3u",NULL); else playlist_name_utf8 = g_strconcat(playlist_path_utf8,G_DIR_SEPARATOR_S,playlist_basename_utf8,".m3u",NULL); g_free(playlist_path_utf8); g_free(playlist_basename_utf8); playlist_name = filename_from_display(playlist_name_utf8); { GFile *file = g_file_new_for_path (playlist_name); GError *error = NULL; if (!write_playlist (self, file, &error)) { // Writing fails... msgdialog = gtk_message_dialog_new (GTK_WINDOW (self), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, _("Cannot write playlist file ā%sā"), playlist_name_utf8); gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (msgdialog), "%s", error->message); gtk_window_set_title(GTK_WINDOW(msgdialog),_("Playlist File Error")); gtk_dialog_run(GTK_DIALOG(msgdialog)); gtk_widget_destroy(msgdialog); g_error_free (error); }else { gchar *msg; msg = g_strdup_printf (_("Wrote playlist file ā%sā"), playlist_name_utf8); et_application_window_status_bar_message (ET_APPLICATION_WINDOW (MainWindow), msg, TRUE); g_free (msg); } g_object_unref (file); } g_free(playlist_name_utf8); g_free(playlist_name); }
gboolean Read_Directory (const gchar *path_real) { GFile *dir; GFileEnumerator *dir_enumerator; GError *error = NULL; gchar *msg; gchar progress_bar_text[30]; guint nbrfile = 0; double fraction; GList *FileList = NULL; GList *l; gint progress_bar_index = 0; GAction *action; EtApplicationWindow *window; g_return_val_if_fail (path_real != NULL, FALSE); ReadingDirectory = TRUE; /* A flag to avoid to start another reading */ /* Initialize file list */ ET_Core_Free (); ET_Core_Create (); et_application_window_update_actions (ET_APPLICATION_WINDOW (MainWindow)); window = ET_APPLICATION_WINDOW (MainWindow); /* Initialize browser list */ et_application_window_browser_clear (window); /* Clear entry boxes */ et_application_window_file_area_clear (window); et_application_window_tag_area_clear (window); // Set to unsensitive the Browser Area, to avoid to select another file while loading the first one et_application_window_browser_set_sensitive (window, FALSE); /* Placed only here, to empty the previous list of files */ dir = g_file_new_for_path (path_real); dir_enumerator = g_file_enumerate_children (dir, G_FILE_ATTRIBUTE_STANDARD_NAME "," G_FILE_ATTRIBUTE_STANDARD_TYPE "," G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN, G_FILE_QUERY_INFO_NONE, NULL, &error); if (!dir_enumerator) { // Message if the directory doesn't exist... GtkWidget *msgdialog; gchar *display_path = g_filename_display_name (path_real); msgdialog = gtk_message_dialog_new(GTK_WINDOW(MainWindow), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, _("Cannot read directory ā%sā"), display_path); gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (msgdialog), "%s", error->message); gtk_window_set_title(GTK_WINDOW(msgdialog),_("Directory Read Error")); gtk_dialog_run(GTK_DIALOG(msgdialog)); gtk_widget_destroy(msgdialog); g_free (display_path); ReadingDirectory = FALSE; //Allow a new reading et_application_window_browser_set_sensitive (window, TRUE); g_object_unref (dir); g_error_free (error); return FALSE; } /* Open the window to quit recursion (since 27/04/2007 : not only into recursion mode) */ et_application_window_set_busy_cursor (window); action = g_action_map_lookup_action (G_ACTION_MAP (MainWindow), "stop"); g_settings_bind (MainSettings, "browse-subdir", G_SIMPLE_ACTION (action), "enabled", G_SETTINGS_BIND_GET); Open_Quit_Recursion_Function_Window(); /* Read the directory recursively */ msg = g_strdup_printf(_("Search in progressā¦")); et_application_window_status_bar_message (window, msg, FALSE); g_free (msg); /* Search the supported files. */ FileList = read_directory_recursively (FileList, dir_enumerator, g_settings_get_boolean (MainSettings, "browse-subdir")); g_file_enumerator_close (dir_enumerator, NULL, &error); g_object_unref (dir_enumerator); g_object_unref (dir); nbrfile = g_list_length(FileList); et_application_window_progress_set_fraction (window, 0.0); g_snprintf (progress_bar_text, 30, "%d/%u", 0, nbrfile); et_application_window_progress_set_text (window, progress_bar_text); // Load the supported files (Extension recognized) for (l = FileList; l != NULL && !Main_Stop_Button_Pressed; l = g_list_next (l)) { GFile *file = l->data; gchar *filename_real = g_file_get_path (file); gchar *display_path = g_filename_display_name (filename_real); msg = g_strdup_printf (_("File: ā%sā"), display_path); et_application_window_status_bar_message (window, msg, FALSE); g_free(msg); g_free (filename_real); g_free (display_path); ETCore->ETFileList = et_file_list_add (ETCore->ETFileList, file); /* Update the progress bar. */ fraction = (++progress_bar_index) / (double) nbrfile; et_application_window_progress_set_fraction (window, fraction); g_snprintf (progress_bar_text, 30, "%d/%u", progress_bar_index, nbrfile); et_application_window_progress_set_text (window, progress_bar_text); while (gtk_events_pending()) gtk_main_iteration(); } g_list_free_full (FileList, g_object_unref); et_application_window_progress_set_text (window, ""); /* Close window to quit recursion */ Destroy_Quit_Recursion_Function_Window(); Main_Stop_Button_Pressed = FALSE; action = g_action_map_lookup_action (G_ACTION_MAP (MainWindow), "stop"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), FALSE); //ET_Debug_Print_File_List(ETCore->ETFileList,__FILE__,__LINE__,__FUNCTION__); if (ETCore->ETFileList) { //GList *etfilelist; /* Load the list of file into the browser list widget */ et_application_window_browser_toggle_display_mode (window); /* Display the first file */ //No need to select first item, because Browser_Display_Tree_Or_Artist_Album_List() does this //etfilelist = ET_Displayed_File_List_First(); //if (etfilelist) //{ // ET_Display_File_Data_To_UI((ET_File *)etfilelist->data); // Browser_List_Select_File_By_Etfile((ET_File *)etfilelist->data,FALSE); //} /* Prepare message for the status bar */ if (g_settings_get_boolean (MainSettings, "browse-subdir")) { msg = g_strdup_printf (ngettext ("Found one file in this directory and subdirectories", "Found %u files in this directory and subdirectories", ETCore->ETFileDisplayedList_Length), ETCore->ETFileDisplayedList_Length); } else { msg = g_strdup_printf (ngettext ("Found one file in this directory", "Found %u files in this directory", ETCore->ETFileDisplayedList_Length), ETCore->ETFileDisplayedList_Length); } }else { /* Clear entry boxes */ et_application_window_file_area_clear (ET_APPLICATION_WINDOW (MainWindow)); et_application_window_tag_area_clear (ET_APPLICATION_WINDOW (MainWindow)); /* Translators: No files, as in "0 files". */ et_application_window_browser_label_set_text (ET_APPLICATION_WINDOW (MainWindow), _("No files")); /* See in ET_Display_Filename_To_UI */ /* Prepare message for the status bar */ if (g_settings_get_boolean (MainSettings, "browse-subdir")) msg = g_strdup(_("No file found in this directory and subdirectories")); else msg = g_strdup(_("No file found in this directory")); } /* Update sensitivity of buttons and menus */ et_application_window_update_actions (window); et_application_window_browser_set_sensitive (window, TRUE); et_application_window_progress_set_fraction (window, 0.0); et_application_window_status_bar_message (window, msg, FALSE); g_free (msg); et_application_window_set_normal_cursor (window); ReadingDirectory = FALSE; return TRUE; }
gint main (gint argc, gchar **argv) { GError *error = NULL; GtkWidget *dialog; GtkWidget *button; gint result; gint retval = EXIT_SUCCESS; gint default_response = GTK_RESPONSE_CANCEL; XfconfChannel *channel; gint configver; gchar *filename_46; gchar *filename_default; gboolean migrate_vendor_default; /* set translation domain */ xfce_textdomain (GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR, "UTF-8"); #ifndef NDEBUG /* terminate the program on warnings and critical messages */ g_log_set_always_fatal (G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING); #endif gtk_init (&argc, &argv); if (!xfconf_init (&error)) { g_critical ("Failed to initialize Xfconf: %s", error->message); g_error_free (error); return EXIT_FAILURE; } channel = xfconf_channel_get (XFCE_PANEL_CHANNEL_NAME); if (!xfconf_channel_has_property (channel, "/panels")) { /* lookup the old 4.6 config file */ filename_46 = xfce_resource_lookup (XFCE_RESOURCE_CONFIG, XFCE_46_CONFIG); /* lookup the default configuration */ xfce_resource_push_path (XFCE_RESOURCE_CONFIG, XDGCONFIGDIR); filename_default = xfce_resource_lookup (XFCE_RESOURCE_CONFIG, DEFAULT_CONFIG_FILENAME); xfce_resource_pop_path (XFCE_RESOURCE_CONFIG); if (filename_46 == NULL && filename_default == NULL) { g_warning ("No default or old configuration found"); return EXIT_FAILURE; } /* if the default configuration does not match with the file found * by the resource lookup, migrate it without asking */ migrate_vendor_default = (g_strcmp0 (DEFAULT_CONFIG_PATH, filename_default) != 0); /* check if we auto-migrate the default configuration */ if (g_getenv ("XFCE_PANEL_MIGRATE_DEFAULT") != NULL || migrate_vendor_default) { if (filename_46 != NULL) g_message ("Tried to auto-migrate, but old configuration found"); else if (filename_default == NULL) g_message ("Tried to auto-migrate, but no default configuration found"); else goto migrate_default; } /* create question dialog */ dialog = gtk_message_dialog_new (NULL, 0, GTK_MESSAGE_QUESTION, GTK_BUTTONS_NONE, _("Welcome to the first start of the panel")); gtk_window_set_title (GTK_WINDOW (dialog), _("Panel")); gtk_window_set_icon_name (GTK_WINDOW (dialog), GTK_STOCK_PREFERENCES); gtk_window_stick (GTK_WINDOW (dialog)); gtk_window_set_keep_above (GTK_WINDOW (dialog), TRUE); if (filename_46 != NULL) { gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), "%s\n%s", _("Because the panel moved to a new system for storing the " "settings, it has to load a fresh initial configuration."), _("Choose below which setup you want for the first startup.")); button = gtk_dialog_add_button (GTK_DIALOG (dialog), _("Migrate old config"), GTK_RESPONSE_OK); gtk_widget_set_tooltip_text (button, _("Migrate the old 4.6 configuration to Xfconf")); default_response = GTK_RESPONSE_OK; } else { gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), _("Choose below which setup you want for the first startup.")); } if (filename_default != NULL) { button = gtk_dialog_add_button (GTK_DIALOG (dialog), _("Use default config"), GTK_RESPONSE_YES); gtk_widget_set_tooltip_text (button, _("Load the default configuration")); if (default_response == GTK_RESPONSE_CANCEL) default_response = GTK_RESPONSE_YES; } button = gtk_dialog_add_button (GTK_DIALOG (dialog), _("One empty panel"), GTK_RESPONSE_CANCEL); gtk_widget_set_tooltip_text (button, _("Start with one empty panel")); gtk_dialog_set_default_response (GTK_DIALOG (dialog), default_response); result = gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); if (result == GTK_RESPONSE_OK && filename_46 != NULL) { /* restore 4.6 config */ if (!migrate_46 (filename_46, channel, &error)) { xfce_dialog_show_error (NULL, error, _("Failed to migrate the old panel configuration")); g_error_free (error); retval = EXIT_FAILURE; } } else if (result == GTK_RESPONSE_YES && filename_default != NULL) { migrate_default: /* apply default config */ if (!migrate_default (filename_default, &error)) { xfce_dialog_show_error (NULL, error, _("Failed to load the default configuration")); g_error_free (error); retval = EXIT_FAILURE; } } g_free (filename_46); g_free (filename_default); } configver = xfconf_channel_get_int (channel, "/configver", -1); if (configver < XFCE4_PANEL_CONFIG_VERSION) { g_message (_("Panel config needs migration...")); if (!migrate_config (channel, configver, &error)) { xfce_dialog_show_error (NULL, error, _("Failed to migrate the existing configuration")); g_error_free (error); retval = EXIT_FAILURE; } else { g_message (_("Panel configuration has been updated.")); } /* migration complete, set new version */ xfconf_channel_set_int (channel, "/configver", XFCE4_PANEL_CONFIG_VERSION); } xfconf_shutdown (); return retval; }
/** * 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; }
static void pin_dialog (DBusGProxy *adapter, DBusGProxy *device, const char *name, const char *long_name, gboolean numeric, DBusGMethodInvocation *context) { GtkWidget *dialog; GtkWidget *button; GtkWidget *entry; GtkBuilder *xml; char *str; input_data *input; xml = gtk_builder_new (); if (gtk_builder_add_from_file (xml, "passkey-dialogue.ui", NULL) == 0) gtk_builder_add_from_file (xml, PKGDATADIR "/passkey-dialogue.ui", NULL); input = g_new0 (input_data, 1); input->path = g_strdup (dbus_g_proxy_get_path(adapter)); input->numeric = numeric; input->context = context; input->device = g_object_ref (device); 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; gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK); gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), GTK_RESPONSE_OK, FALSE); 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); gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), _("Please enter the PIN mentioned on device %s."), long_name); entry = GTK_WIDGET (gtk_builder_get_object (xml, "entry")); if (numeric == TRUE) { gtk_entry_set_max_length (GTK_ENTRY (entry), 6); gtk_entry_set_width_chars (GTK_ENTRY (entry), 6); g_signal_connect (G_OBJECT (entry), "insert-text", G_CALLBACK (insert_callback), input); } else { gtk_entry_set_max_length (GTK_ENTRY (entry), 16); gtk_entry_set_width_chars (GTK_ENTRY (entry), 16); gtk_entry_set_visibility (GTK_ENTRY (entry), FALSE); } gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE); input->entry = entry; g_signal_connect (G_OBJECT (entry), "changed", G_CALLBACK (changed_callback), input); button = GTK_WIDGET (gtk_builder_get_object (xml, "showinput_button")); if (numeric == FALSE) { g_signal_connect (G_OBJECT (button), "toggled", G_CALLBACK (toggled_callback), input); } else { gtk_widget_set_no_show_all (button, TRUE); gtk_widget_hide (button); } input_list = g_list_append(input_list, input); g_signal_connect (G_OBJECT (dialog), "response", G_CALLBACK (pin_callback), input); enable_blinking(); }
static void show_dialog(MateDACapplet* capplet, const gchar* start_page) { #define get_widget(name) GTK_WIDGET(gtk_builder_get_object(builder, name)) GtkBuilder* builder; guint builder_result; capplet->builder = builder = gtk_builder_new (); if (g_file_test(MATECC_UI_DIR "/mate-default-applications-properties.ui", G_FILE_TEST_EXISTS) != FALSE) { builder_result = gtk_builder_add_from_file(builder, MATECC_UI_DIR "/mate-default-applications-properties.ui", NULL); } else { builder_result = gtk_builder_add_from_file(builder, "./mate-default-applications-properties.ui", NULL); } if (builder_result == 0) { GtkWidget* dialog = gtk_message_dialog_new (NULL, 0, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Could not load the main interface")); gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), _("Please make sure that the applet is properly installed")); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK); gtk_dialog_run(GTK_DIALOG(dialog)); gtk_widget_destroy(dialog); exit(EXIT_FAILURE); } capplet->window = get_widget("preferred_apps_dialog"); g_signal_connect(capplet->window, "response", G_CALLBACK(close_cb), NULL); capplet->web_combo_box = get_widget("web_browser_combobox"); capplet->mail_combo_box = get_widget("mail_reader_combobox"); capplet->term_combo_box = get_widget("terminal_combobox"); capplet->media_combo_box = get_widget("media_player_combobox"); capplet->video_combo_box = get_widget("video_combobox"); capplet->visual_combo_box = get_widget("visual_combobox"); capplet->mobility_combo_box = get_widget("mobility_combobox"); capplet->text_combo_box = get_widget("text_combobox"); capplet->file_combo_box = get_widget("filemanager_combobox"); capplet->image_combo_box = get_widget("image_combobox"); g_signal_connect(capplet->window, "screen-changed", G_CALLBACK(screen_changed_cb), capplet); screen_changed_cb(capplet->window, gdk_screen_get_default(), capplet); // lists capplet->web_browsers = g_app_info_get_all_for_type("x-scheme-handler/http"); capplet->mail_readers = g_app_info_get_all_for_type("x-scheme-handler/mailto"); //capplet->terminals = g_app_info_get_all_for_type("inode/directory"); capplet->media_players = g_app_info_get_all_for_type("audio/x-vorbis+ogg"); capplet->video_players = g_app_info_get_all_for_type("video/x-ogm+ogg"); //capplet->visual_ats = g_app_info_get_all_for_type("inode/directory"); //capplet->mobility_ats = g_app_info_get_all_for_type("inode/directory"); capplet->text_editors = g_app_info_get_all_for_type("text/plain"); capplet->image_viewers = g_app_info_get_all_for_type("image/png"); capplet->file_managers = g_app_info_get_all_for_type("inode/directory"); fill_combo_box(capplet->icon_theme, GTK_COMBO_BOX(capplet->web_combo_box), capplet->web_browsers, "x-scheme-handler/http"); fill_combo_box(capplet->icon_theme, GTK_COMBO_BOX(capplet->mail_combo_box), capplet->mail_readers, "x-scheme-handler/mailto"); //fill_combo_box(capplet->icon_theme, GTK_COMBO_BOX(capplet->term_combo_box), capplet->terminals, ""); fill_combo_box(capplet->icon_theme, GTK_COMBO_BOX(capplet->media_combo_box), capplet->media_players, "audio/x-vorbis+ogg"); fill_combo_box(capplet->icon_theme, GTK_COMBO_BOX(capplet->video_combo_box), capplet->video_players, "video/x-ogm+ogg"); //fill_combo_box(capplet->icon_theme, GTK_COMBO_BOX(capplet->visual_combo_box), capplet->visual_ats, NULL); //fill_combo_box(capplet->icon_theme, GTK_COMBO_BOX(capplet->mobility_combo_box), capplet->mobility_ats, NULL); fill_combo_box(capplet->icon_theme, GTK_COMBO_BOX(capplet->image_combo_box), capplet->image_viewers, "image/png"); fill_combo_box(capplet->icon_theme, GTK_COMBO_BOX(capplet->text_combo_box), capplet->text_editors, "text/plain"); fill_combo_box(capplet->icon_theme, GTK_COMBO_BOX(capplet->file_combo_box), capplet->file_managers, "inode/directory"); g_signal_connect(capplet->web_combo_box, "changed", G_CALLBACK(web_combo_changed_cb), capplet); g_signal_connect(capplet->mail_combo_box, "changed", G_CALLBACK(mail_combo_changed_cb), capplet); g_signal_connect(capplet->term_combo_box, "changed", G_CALLBACK(terminal_combo_changed_cb), capplet); g_signal_connect(capplet->media_combo_box, "changed", G_CALLBACK(media_combo_changed_cb), capplet); g_signal_connect(capplet->video_combo_box, "changed", G_CALLBACK(video_combo_changed_cb), capplet); g_signal_connect(capplet->visual_combo_box, "changed", G_CALLBACK(visual_combo_changed_cb), capplet); g_signal_connect(capplet->mobility_combo_box, "changed", G_CALLBACK(mobility_combo_changed_cb), capplet); g_signal_connect(capplet->image_combo_box, "changed", G_CALLBACK(image_combo_changed_cb), capplet); g_signal_connect(capplet->text_combo_box, "changed", G_CALLBACK(text_combo_changed_cb), capplet); g_signal_connect(capplet->file_combo_box, "changed", G_CALLBACK(file_combo_changed_cb), capplet); /* TODO: fix the name icon */ gtk_window_set_icon_name(GTK_WINDOW (capplet->window), "preferences-desktop-default-applications"); if (start_page != NULL) { gchar* page_name; GtkWidget* w; page_name = g_strconcat (start_page, "_vbox", NULL); w = get_widget(page_name); if (w != NULL) { GtkNotebook* nb; gint pindex; nb = GTK_NOTEBOOK(get_widget("preferred_apps_notebook")); pindex = gtk_notebook_page_num(nb, w); if (pindex != -1) { gtk_notebook_set_current_page(nb, pindex); } } g_free(page_name); } gtk_widget_show(capplet->window); #undef get_widget }
/* ---------------------------------------------- */ gint ghid_dialog_close_confirm () { GtkWidget *dialog; gint rv; GHidPort *out = &ghid_port; gchar *tmp; gchar *str; if (PCB->Filename == NULL) { tmp = g_strdup_printf ( _("Save the changes to layout before closing?")); } else { tmp = g_strdup_printf ( _("Save the changes to layout \"%s\" before closing?"), PCB->Filename); } str = g_strconcat ("<big><b>", tmp, "</b></big>", NULL); g_free (tmp); tmp = _("If you don't save, all your changes will be permanently lost."); str = g_strconcat (str, "\n\n", tmp, NULL); dialog = gtk_message_dialog_new (GTK_WINDOW (out->top_window), (GtkDialogFlags)(GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT), GTK_MESSAGE_WARNING, GTK_BUTTONS_NONE, NULL); gtk_message_dialog_set_markup (GTK_MESSAGE_DIALOG (dialog), str); gtk_dialog_add_buttons (GTK_DIALOG (dialog), _("Close _without saving"), GTK_RESPONSE_NO, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_YES, NULL); /* Set the alternative button order (ok, cancel, help) for other systems */ gtk_dialog_set_alternative_button_order(GTK_DIALOG(dialog), GTK_RESPONSE_YES, GTK_RESPONSE_NO, GTK_RESPONSE_CANCEL, -1); switch (gtk_dialog_run (GTK_DIALOG (dialog))) { case GTK_RESPONSE_NO: { rv = GUI_DIALOG_CLOSE_CONFIRM_NOSAVE; break; } case GTK_RESPONSE_YES: { rv = GUI_DIALOG_CLOSE_CONFIRM_SAVE; break; } case GTK_RESPONSE_CANCEL: default: { rv = GUI_DIALOG_CLOSE_CONFIRM_CANCEL; break; } } gtk_widget_destroy (dialog); return rv; }
int lassi_tray_init(LassiTrayInfo *i, LassiServer *server) { GtkActionEntry entries[] = { #if GTK_CHECK_VERSION(2,14,0) {"Help", GTK_STOCK_HELP, NULL, NULL, NULL, G_CALLBACK (on_help_activate)}, #endif {"Preferences", GTK_STOCK_PREFERENCES, NULL, NULL, NULL, G_CALLBACK (on_prefs_activate)}, {"Quit", GTK_STOCK_QUIT, NULL, NULL, NULL, G_CALLBACK (gtk_main_quit)} }; GtkActionGroup *actions; GError *error = NULL; g_assert(i); g_assert(server); memset(i, 0, sizeof(*i)); i->server = server; notify_init("Mango Lassi"); i->status_icon = gtk_status_icon_new_from_icon_name(ICON_IDLE); i->ui_manager = gtk_ui_manager_new (); actions = gtk_action_group_new ("mango-lassi-popup"); gtk_action_group_add_actions (actions, entries, G_N_ELEMENTS (entries), i); gtk_ui_manager_insert_action_group (i->ui_manager, actions, -1); gtk_ui_manager_add_ui_from_string (i->ui_manager, "<popup>" "<menuitem action='Preferences'/>" #if GTK_CHECK_VERSION(2,14,0) "<menuitem action='Help'/>" #endif "<separator />" "<menuitem action='Quit'/>" "</popup>", -1, &error); if (error) { GtkWidget* dialog = gtk_message_dialog_new (NULL, 0, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "%s", _("Initialization Error")); gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), _("Cannot initialize the user interface: %s"), error->message); g_error_free (error); gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); return 1; } i->menu = gtk_ui_manager_get_widget (i->ui_manager, "/ui/popup"); g_signal_connect(G_OBJECT(i->status_icon), "popup_menu", G_CALLBACK(on_tray_popup_menu), i); g_signal_connect(G_OBJECT(i->status_icon), "activate", G_CALLBACK(on_tray_activate), i); lassi_tray_update(i, 0); return 0; }
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); }