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