static void
on_action_save (GtkAction *action, LdWindowMain *self)
{
if (!self->priv->filename
|| !diagram_save (self, GTK_WINDOW (self), self->priv->filename))
diagram_show_save_as_dialog (self);
}
/*
* diagram_show_save_as_dialog:
*
* Show a dialog for saving the diagram.
*/
static void
diagram_show_save_as_dialog (LdWindowMain *self)
{
GtkWidget *dialog;
g_return_if_fail (LD_IS_WINDOW_MAIN (self));
dialog = gtk_file_chooser_dialog_new (_("Save As..."), GTK_WINDOW (self),
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
NULL);
g_object_set (dialog, "do-overwrite-confirmation", TRUE, NULL);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog),
diagram_get_file_filter ());
if (self->priv->filename)
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (dialog),
self->priv->filename);
while (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
{
gchar *filename;
filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
if (diagram_save (self, GTK_WINDOW (dialog), filename))
{
diagram_set_filename (self, filename);
break;
}
g_free (filename);
}
gtk_widget_destroy (dialog);
}
static PyObject *
PyDiaDiagram_Save(PyDiaDiagram *self, PyObject *args)
{
gchar *filename = self->dia->filename;
if (!PyArg_ParseTuple(args, "|s:Diagram.save", &filename))
return NULL;
return PyInt_FromLong(diagram_save(self->dia, filename));
}
static void
are_you_sure_close_dialog_respond(GtkWidget *widget, /* the dialog */
gint response_id,
gpointer user_data) /* the display */
{
DDisplay *ddisp = (DDisplay *)user_data;
gboolean close_ddisp = TRUE;
switch (response_id) {
case GTK_RESPONSE_YES :
/* save changes */
if (ddisp->diagram->unsaved) {
/* we have to open the file dlg, close this one first */
gtk_widget_destroy(widget);
if (file_save_as(ddisp->diagram, ddisp))
ddisp_destroy (ddisp);
/* no way back */
return;
} else {
DiaContext *ctx = dia_context_new (_("Save"));
if (!diagram_save(ddisp->diagram, ddisp->diagram->filename, ctx))
close_ddisp = FALSE;
dia_context_release (ctx);
}
if (close_ddisp) /* saving succeeded */
recent_file_history_add(ddisp->diagram->filename);
if (ddisp->update_id && close_ddisp) {
g_source_remove (ddisp->update_id);
ddisp->update_id = 0;
}
/* fall through */
case GTK_RESPONSE_NO :
if (close_ddisp)
ddisp_destroy (ddisp);
/* fall through */
case GTK_RESPONSE_CANCEL :
case GTK_RESPONSE_NONE :
case GTK_RESPONSE_DELETE_EVENT : /* closing via window manager */
gtk_widget_destroy(widget);
break;
default :
g_assert_not_reached();
}
}
gboolean
app_exit(void)
{
GList *list;
GSList *slist;
/*
* The following "solves" a crash related to a second call of app_exit,
* after gtk_main_quit was called. It may be a win32 gtk-1.3.x bug only
* but the check shouldn't hurt on *ix either. --hb
*/
static gboolean app_exit_once = FALSE;
if (app_exit_once) {
g_error(_("This shouldn't happen. Please file a bug report at bugzilla.gnome.org\n"
"describing how you caused this message to appear.\n"));
return FALSE;
}
if (diagram_modified_exists()) {
if (is_integrated_ui ())
{
GtkWidget *dialog;
int result;
exit_dialog_item_array_t *items = NULL;
GList * list;
Diagram * diagram;
dialog = exit_dialog_make (GTK_WINDOW (interface_get_toolbox_shell ()),
_("Exiting Dia"));
list = dia_open_diagrams();
while (list)
{
diagram = list->data;
if (diagram_is_modified (diagram))
{
const gchar * name = diagram_get_name (diagram);
const gchar * path = diagram->filename;
exit_dialog_add_item (dialog, name, path, diagram);
}
list = g_list_next (list);
}
result = exit_dialog_run (dialog, &items);
gtk_widget_destroy (dialog);
if (result == EXIT_DIALOG_EXIT_CANCEL)
{
return FALSE;
}
else if (result == EXIT_DIALOG_EXIT_SAVE_SELECTED)
{
DiaContext *ctx = dia_context_new(_("Save"));
int i;
for (i = 0 ; i < items->array_size ; i++) {
gchar *filename;
diagram = items->array[i].data;
filename = g_filename_from_utf8 (diagram->filename, -1, NULL, NULL, NULL);
diagram_update_extents (diagram);
dia_context_set_filename (ctx, filename);
if (!diagram_save (diagram, filename, ctx)) {
exit_dialog_free_items (items);
dia_context_release (ctx);
return FALSE;
} else {
dia_context_reset (ctx);
}
g_free (filename);
}
dia_context_release (ctx);
exit_dialog_free_items (items);
}
else if (result == EXIT_DIALOG_EXIT_NO_SAVE)
{
list = dia_open_diagrams();
while (list) {
diagram = list->data;
/* slight hack: don't ask again */
diagram_set_modified (diagram, FALSE);
undo_clear(diagram->undo);
list = g_list_next (list);
}
}
}
else
{
GtkWidget *dialog;
GtkWidget *button;
dialog = gtk_message_dialog_new(
NULL, GTK_DIALOG_MODAL,
GTK_MESSAGE_QUESTION,
GTK_BUTTONS_NONE, /* no standard buttons */
_("Quitting without saving modified diagrams"));
gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog),
_("Modified diagrams exist. "
"Are you sure you want to quit Dia "
"without saving them?"));
gtk_window_set_title (GTK_WINDOW(dialog), _("Quit Dia"));
button = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
gtk_dialog_add_action_widget (GTK_DIALOG(dialog), button, GTK_RESPONSE_CANCEL);
#if GTK_CHECK_VERSION(2,18,0)
gtk_widget_set_can_default (GTK_WIDGET (button), TRUE);
#else
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
#endif
gtk_dialog_set_default_response (GTK_DIALOG(dialog), GTK_RESPONSE_CANCEL);
button = gtk_button_new_from_stock (GTK_STOCK_QUIT);
gtk_dialog_add_action_widget (GTK_DIALOG(dialog), button, GTK_RESPONSE_OK);
gtk_widget_show_all (dialog);
if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
gtk_widget_destroy(dialog);
return FALSE;
}
gtk_widget_destroy(dialog);
}
}
prefs_save();
persistence_save();
dynobj_refresh_finish();
{
DiaContext *ctx = dia_context_new (_("Exit"));
dia_object_defaults_save (NULL, ctx);
dia_context_release (ctx);
}
/* Free loads of stuff (toolbox) */
list = dia_open_diagrams();
while (list!=NULL) {
Diagram *dia = (Diagram *)list->data;
list = g_list_next(list);
slist = dia->displays;
while (slist!=NULL) {
DDisplay *ddisp = (DDisplay *)slist->data;
slist = g_slist_next(slist);
gtk_widget_destroy(ddisp->shell);
}
/* The diagram is freed when the last display is destroyed */
}
/* save pluginrc */
if (dia_is_interactive)
dia_pluginrc_write();
gtk_main_quit();
/* This printf seems to prevent a race condition with unrefs. */
/* Yuck. -Lars */
/* Trying to live without it. -Lars 10/8/07*/
/* g_print(_("Thank you for using Dia.\n")); */
app_exit_once = TRUE;
return TRUE;
}
static GtkWidget *
file_save_as_dialog_prepare (Diagram *dia, DDisplay *ddisp)
{
gchar *filename = NULL;
if (!savedlg) {
GtkWidget *compressbutton;
savedlg = gtk_file_chooser_dialog_new(_("Save Diagram"),
GTK_WINDOW(ddisp->shell),
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
NULL);
/* vfs saving is as easy - if you see 'bad file descriptor' there is
* something wrong with the permissions of the share ;) */
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER(savedlg), FALSE);
gtk_dialog_set_default_response(GTK_DIALOG(savedlg), GTK_RESPONSE_ACCEPT);
gtk_window_set_role(GTK_WINDOW(savedlg), "save_diagram");
/* Need better way to make it a reasonable size. Isn't there some*/
/* standard look for them (or is that just Gnome?)*/
compressbutton = gtk_check_button_new_with_label(_("Compress diagram files"));
gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(savedlg),
compressbutton);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(compressbutton),
dia->data->is_compressed);
g_signal_connect(G_OBJECT(compressbutton), "toggled",
G_CALLBACK(toggle_compress_callback), NULL);
gtk_widget_show(compressbutton);
gtk_widget_set_tooltip_text (compressbutton,
_("Compression reduces file size to less than 1/10th "
"size and speeds up loading and saving. Some text "
"programs cannot manipulate compressed files."));
g_signal_connect (GTK_FILE_CHOOSER(savedlg),
"response", G_CALLBACK(file_save_as_response_callback), compressbutton);
g_signal_connect(G_OBJECT(savedlg), "destroy",
G_CALLBACK(gtk_widget_destroyed), &savedlg);
} else {
GtkWidget *compressbutton = gtk_file_chooser_get_extra_widget(GTK_FILE_CHOOSER(savedlg));
gtk_widget_set_sensitive(savedlg, TRUE);
g_signal_handlers_block_by_func(G_OBJECT(compressbutton), toggle_compress_callback, NULL);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(compressbutton),
dia->data->is_compressed);
g_signal_handlers_unblock_by_func(G_OBJECT(compressbutton), toggle_compress_callback, NULL);
if (g_object_get_data (G_OBJECT (savedlg), "user_data") != NULL)
g_object_unref (g_object_get_data (G_OBJECT (savedlg), "user_data"));
#if GTK_CHECK_VERSION(2,20,0)
if (gtk_widget_get_visible(savedlg)) {
#else
if (GTK_WIDGET_VISIBLE(savedlg)) {
#endif
/* keep a refernce to the diagram */
g_object_ref(dia);
g_object_set_data (G_OBJECT (savedlg), "user_data", dia);
gtk_window_present (GTK_WINDOW(savedlg));
return savedlg;
}
}
if (dia && dia->filename)
filename = g_filename_from_utf8(dia->filename, -1, NULL, NULL, NULL);
if (filename != NULL) {
char* fnabs = dia_get_absolute_filename (filename);
if (fnabs) {
gchar *base = g_path_get_basename(dia->filename);
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(savedlg), fnabs);
/* FileChooser api insist on exiting files for set_filename */
/* ... and does not use filename encoding on this one. */
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(savedlg), base);
g_free(base);
}
g_free(fnabs);
g_free(filename);
}
g_object_ref(dia);
g_object_set_data (G_OBJECT (savedlg), "user_data", dia);
return savedlg;
}
/**
* Respond to the File/Save menu entry.
*
* Delegates to Save As if there is no filename set yet.
*/
void
file_save_callback(GtkAction *action)
{
Diagram *diagram;
diagram = ddisplay_active_diagram();
if (!diagram) return;
if (diagram->unsaved) {
file_save_as_callback(action);
} else {
gchar *filename = g_filename_from_utf8(diagram->filename, -1, NULL, NULL, NULL);
DiaContext *ctx = dia_context_new (_("Save"));
diagram_update_extents(diagram);
if (diagram_save(diagram, filename, ctx))
recent_file_history_add(filename);
g_free (filename);
dia_context_release (ctx);
}
}
/**
* Respond to a button press (also destroy) in the save as dialog.
*/
static void
file_save_as_response_callback(GtkWidget *fs,
gint response,
gpointer user_data)
{
char *filename;
Diagram *dia;
struct stat stat_struct;
if (response == GTK_RESPONSE_ACCEPT) {
dia = g_object_get_data (G_OBJECT(fs), "user_data");
filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(fs));
if (!filename) {
/* Not getting a filename looks like a contract violation in Gtk+ to me.
* Still Dia would be crashing (bug #651949) - instead simply go back to the dialog. */
gtk_window_present (GTK_WINDOW (fs));
return;
}
if (g_stat(filename, &stat_struct) == 0) {
GtkWidget *dialog = NULL;
char *utf8filename = NULL;
if (!g_utf8_validate(filename, -1, NULL)) {
utf8filename = g_filename_to_utf8(filename, -1, NULL, NULL, NULL);
if (utf8filename == NULL) {
message_warning(_("Some characters in the filename are neither UTF-8\n"
"nor your local encoding.\nSome things will break."));
}
}
if (utf8filename == NULL) utf8filename = g_strdup(filename);
dialog = gtk_message_dialog_new (GTK_WINDOW(fs),
GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION,
GTK_BUTTONS_YES_NO,
_("File already exists"));
gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog),
_("The file '%s' already exists.\n"
"Do you want to overwrite it?"), utf8filename);
g_free(utf8filename);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_YES);
if (gtk_dialog_run (GTK_DIALOG (dialog)) != GTK_RESPONSE_YES) {
/* don't hide/destroy the dialog, but simply go back to it */
gtk_window_present (GTK_WINDOW (fs));
gtk_widget_destroy(dialog);
g_free (filename);
return;
}
gtk_widget_destroy(dialog);
}
dia->data->is_compressed = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(user_data));
diagram_update_extents(dia);
{
DiaContext *ctx = dia_context_new (_("Save as"));
diagram_set_filename(dia, filename);
dia_context_set_filename (ctx, filename);
if (diagram_save(dia, filename, ctx))
recent_file_history_add(filename);
dia_context_release (ctx);
}
g_free (filename);
}
/* if we have our own reference, drop it before destroy */
if ((dia = g_object_get_data (G_OBJECT(fs), "user_data")) != NULL) {
g_object_set_data (G_OBJECT(fs), "user_data", NULL);
g_object_unref (dia);
}
/* if we destroy it gtk_dialog_run wont give the response */
if (!g_object_get_data (G_OBJECT(fs), "dont-destroy"))
gtk_widget_destroy(GTK_WIDGET(fs));
}
