static void
update_floating_toolbox(DiaPrefData *pref, gpointer ptr)
{
g_return_if_fail (pref->key == NULL);
if (!app_is_interactive())
return;
if (prefs.toolbox_on_top) {
/* Go through all diagrams and set toolbox transient for all displays */
GList *diagrams;
for (diagrams = dia_open_diagrams(); diagrams != NULL;
diagrams = g_list_next(diagrams)) {
Diagram *diagram = (Diagram *)diagrams->data;
GSList *displays;
for (displays = diagram->displays; displays != NULL;
displays = g_slist_next(displays)) {
DDisplay *ddisp = (DDisplay *)displays->data;
gtk_window_set_transient_for(GTK_WINDOW(interface_get_toolbox_shell()),
GTK_WINDOW(ddisp->shell));
}
}
} else {
GtkWindow *shell = GTK_WINDOW(interface_get_toolbox_shell());
if (shell)
gtk_window_set_transient_for(shell, NULL);
}
}
static void
ddisp_destroy(DDisplay *ddisp)
{
g_signal_handlers_disconnect_by_func (ddisp->diagram, selection_changed, ddisp);
g_object_unref (G_OBJECT (ddisp->im_context));
ddisp->im_context = NULL;
ddisplay_im_context_preedit_reset(ddisp, get_active_focus((DiagramData *) ddisp->diagram));
if (GTK_WINDOW(ddisp->shell) == gtk_window_get_transient_for(GTK_WINDOW(interface_get_toolbox_shell()))) {
/* we have to break the connection otherwise the toolbox will be closed */
gtk_window_set_transient_for(GTK_WINDOW(interface_get_toolbox_shell()), NULL);
}
/* This calls ddisplay_really_destroy */
if (ddisp->is_standalone_window)
gtk_widget_destroy (ddisp->shell);
else {
gtk_widget_destroy (ddisp->container);
ddisplay_really_destroy (ddisp);
}
}
static void
linewidth_create_dialog()
{
GtkWidget *hbox;
GtkWidget *label;
GtkAdjustment *adj;
linewidth_dialog = gtk_dialog_new_with_buttons(
_("Line width"), GTK_WINDOW(interface_get_toolbox_shell()),
0,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG(linewidth_dialog), GTK_RESPONSE_OK);
gtk_window_set_role (GTK_WINDOW (linewidth_dialog), "linewidth_window");
gtk_window_set_resizable (GTK_WINDOW (linewidth_dialog), TRUE);
gtk_container_set_border_width (GTK_CONTAINER (linewidth_dialog), 2);
hbox = gtk_hbox_new(FALSE, 5);
label = gtk_label_new(_("Line width:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
gtk_widget_show (label);
adj = (GtkAdjustment *) gtk_adjustment_new(0.1, 0.00, 10.0, 0.01, 0.05, 0.0);
linewidth_button = gtk_spin_button_new(adj, attributes_get_default_linewidth(), 2);
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(linewidth_button), TRUE);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(linewidth_button), TRUE);
gtk_box_pack_start(GTK_BOX (hbox), linewidth_button, TRUE, TRUE, 0);
gtk_widget_show (linewidth_button);
gtk_widget_show(hbox);
gtk_box_pack_start (GTK_BOX(GTK_DIALOG (linewidth_dialog)->vbox), hbox, TRUE, TRUE, 0);
gtk_widget_show (linewidth_button);
g_signal_connect(G_OBJECT (linewidth_dialog), "response",
G_CALLBACK (linewidth_dialog_respond), NULL);
g_signal_connect_after(G_OBJECT (linewidth_button), "activate",
G_CALLBACK (linewidth_dialog_ok), NULL);
g_signal_connect (GTK_OBJECT (linewidth_dialog), "delete_event",
G_CALLBACK(gtk_widget_hide), NULL);
g_signal_connect (GTK_OBJECT (linewidth_dialog), "destroy",
G_CALLBACK(dialog_destroyed), &linewidth_dialog);
persistence_register_window (GTK_WINDOW (linewidth_dialog));
}
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;
}
/**
* Handle menu click File/Open
*
* This is either with or without diagram
*/
void
file_open_callback(GtkAction *action)
{
if (!opendlg) {
DDisplay *ddisp;
Diagram *dia = NULL;
GtkWindow *parent_window;
gchar *filename = NULL;
/* FIXME: we should not use ddisp_active but instead get the current diagram
* from caller. Thus we could offer the option to "load into" if invoked by
* <Display/File/Open. It wouldn't make any sense if invoked by
* <Toolbox>/File/Open ...
*/
ddisp = ddisplay_active();
if (ddisp) {
dia = ddisp->diagram;
parent_window = GTK_WINDOW(ddisp->shell);
} else {
parent_window = GTK_WINDOW(interface_get_toolbox_shell());
}
persistence_register_integer ("import-filter", 0);
opendlg = gtk_file_chooser_dialog_new(_("Open Diagram"), parent_window,
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
/* is activating gvfs really that easy - at least it works for samba shares*/
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER(opendlg), FALSE);
gtk_dialog_set_default_response(GTK_DIALOG(opendlg), GTK_RESPONSE_ACCEPT);
gtk_window_set_role(GTK_WINDOW(opendlg), "open_diagram");
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)
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(opendlg), fnabs);
g_free(fnabs);
g_free(filename);
}
g_signal_connect(G_OBJECT(opendlg), "destroy",
G_CALLBACK(gtk_widget_destroyed), &opendlg);
} else {
gtk_widget_set_sensitive(opendlg, TRUE);
#if GTK_CHECK_VERSION(2,20,0)
if (gtk_widget_get_visible(opendlg))
#else
if (GTK_WIDGET_VISIBLE(opendlg))
#endif
return;
}
if (!gtk_file_chooser_get_extra_widget(GTK_FILE_CHOOSER(opendlg))) {
GtkWidget *hbox, *label, *omenu, *options;
GtkFileFilter* filter;
options = gtk_frame_new(_("Open Options"));
gtk_frame_set_shadow_type(GTK_FRAME(options), GTK_SHADOW_ETCHED_IN);
hbox = gtk_hbox_new(FALSE, 1);
gtk_container_set_border_width(GTK_CONTAINER(hbox), 5);
gtk_container_add(GTK_CONTAINER(options), hbox);
gtk_widget_show(hbox);
label = gtk_label_new (_("Determine file type:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
gtk_widget_show (label);
omenu = create_open_menu();
gtk_box_pack_start(GTK_BOX(hbox), omenu, TRUE, TRUE, 0);
gtk_widget_show(omenu);
gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(opendlg),
options);
gtk_widget_show(options);
g_signal_connect(G_OBJECT(opendlg), "response",
G_CALLBACK(file_open_response_callback), omenu);
/* set up the gtk file (name) filters */
/* 0 = by extension */
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (opendlg),
build_gtk_file_filter_from_index (0));
filter = gtk_file_filter_new ();
gtk_file_filter_set_name (filter, _("All Files"));
gtk_file_filter_add_pattern (filter, "*");
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (opendlg), filter);
gtk_combo_box_set_active (GTK_COMBO_BOX (omenu), persistence_get_integer ("import-filter"));
}
gtk_widget_show(opendlg);
}
void
display_set_active(DDisplay *ddisp)
{
if (ddisp != active_display) {
active_display = ddisp;
/* perform notification here (such as switch layers dialog) */
layer_dialog_set_diagram(ddisp ? ddisp->diagram : NULL);
diagram_properties_set_diagram(ddisp ? ddisp->diagram : NULL);
if (ddisp) {
if (ddisp->is_standalone_window)
{
display_update_menu_state(ddisp);
if (prefs.toolbox_on_top) {
gtk_window_set_transient_for(GTK_WINDOW(interface_get_toolbox_shell()),
GTK_WINDOW(ddisp->shell));
} else {
gtk_window_set_transient_for(GTK_WINDOW(interface_get_toolbox_shell()),
NULL);
}
} else {
GtkNotebook *notebook = g_object_get_data (G_OBJECT (ddisp->shell),
DIA_MAIN_NOTEBOOK);
/* Find the page with ddisp then set the label on the tab */
gint num_pages = gtk_notebook_get_n_pages (notebook);
gint num;
GtkWidget *page;
for (num = 0 ; num < num_pages ; num++)
{
page = gtk_notebook_get_nth_page (notebook,num);
if (g_object_get_data (G_OBJECT (page), "DDisplay") == ddisp)
{
gtk_notebook_set_current_page (notebook,num);
break;
}
}
/* synchronize_ui_to_active_display (ddisp); */
/* updates display title, etc */
diagram_modified(ddisp->diagram);
/* ZOOM */
update_zoom_status (ddisp);
/* Snap to grid */
ddisplay_set_snap_to_grid (ddisp, ddisp->grid.snap); /* menus */
/* Object snapping */
ddisplay_set_snap_to_objects (ddisp, ddisp->mainpoint_magnetism);
display_update_menu_state (ddisp);
gtk_window_present (GTK_WINDOW(ddisp->shell));
}
} else {
/* TODO: Prevent gtk_window_set_transient_for() in Integrated UI case */
gtk_window_set_transient_for(GTK_WINDOW(interface_get_toolbox_shell()),
NULL);
}
}
}
static void
prefs_create_dialog(void)
{
GtkWidget *label;
GtkWidget *dialog_vbox;
GtkWidget *notebook;
GtkTable *top_table = NULL; /* top level table for the tab */
GtkTable *current_table = NULL;
int i;
int tab_idx = -1;
if (prefs_dialog != NULL)
return;
prefs_dialog = gtk_dialog_new_with_buttons(
_("Preferences"),
GTK_WINDOW(interface_get_toolbox_shell()),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
GTK_STOCK_APPLY, GTK_RESPONSE_APPLY,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG(prefs_dialog), GTK_RESPONSE_OK);
gtk_window_set_resizable (GTK_WINDOW (prefs_dialog), TRUE);
dialog_vbox = GTK_DIALOG (prefs_dialog)->vbox;
gtk_window_set_role (GTK_WINDOW (prefs_dialog), "preferences_window");
g_signal_connect(G_OBJECT (prefs_dialog), "response",
G_CALLBACK (prefs_respond), NULL);
g_signal_connect (GTK_OBJECT (prefs_dialog), "delete_event",
G_CALLBACK(gtk_widget_hide), NULL);
g_signal_connect (GTK_OBJECT (prefs_dialog), "destroy",
G_CALLBACK(gtk_widget_destroyed), &prefs_dialog);
notebook = gtk_notebook_new ();
gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP);
gtk_box_pack_start (GTK_BOX (dialog_vbox), notebook, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (notebook), 2);
gtk_widget_show (notebook);
for (i=0;i<NUM_PREFS_TABS;i++) {
GtkWidget *table;
GtkWidget *notebook_page;
label = gtk_label_new(gettext(prefs_tabs[i].title));
gtk_widget_show(label);
table = gtk_table_new (9, 2, FALSE);
prefs_tabs[i].table = GTK_TABLE(table);
gtk_widget_set_size_request(table, -1, -1);
gtk_widget_show(table);
#ifdef SCROLLED_PAGES
notebook_page = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (notebook_page),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_show(notebook_page);
#else
notebook_page = table;
#endif/* SCROLLED_PAGES */
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), notebook_page, label);
#ifdef SCROLLED_PAGES
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(notebook_page),
table);
gtk_viewport_set_shadow_type(GTK_VIEWPORT(GTK_BIN(notebook_page)->child),
GTK_SHADOW_NONE);
#endif /* SCROLLED_PAGES */
}
gtk_notebook_set_tab_pos(GTK_NOTEBOOK(notebook), GTK_POS_LEFT);
tab_idx = -1;
for (i=0;i<NUM_PREFS_DATA;i++) {
GtkWidget *widget = NULL;
int row;
if (prefs_data[i].hidden)
continue;
if (tab_idx != prefs_data[i].tab) {
tab_idx = prefs_data[i].tab;
top_table = prefs_tabs[prefs_data[i].tab].table;
current_table = top_table;
}
row = prefs_tabs[tab_idx].row++;
switch(prefs_data[i].type) {
case PREF_NONE:
widget = gtk_frame_new(gettext(prefs_data[i].label_text));
gtk_widget_show (widget);
gtk_table_attach (current_table, widget, 0, 2,
row, row + 1,
GTK_FILL | GTK_EXPAND, GTK_FILL, 1, 1);
current_table = GTK_TABLE(gtk_table_new (9, 2, FALSE));
gtk_container_add(GTK_CONTAINER(widget), GTK_WIDGET(current_table));
gtk_widget_show(GTK_WIDGET(current_table));
break;
case PREF_END_GROUP:
current_table = top_table;
break;
case PREF_BOOLEAN:
widget = gtk_check_button_new_with_label (gettext(prefs_data[i].label_text));
gtk_widget_show (widget);
gtk_table_attach (current_table, widget, 0, 2,
row, row + 1,
GTK_FILL | GTK_EXPAND, GTK_FILL, 1, 1);
break;
default:
label = gtk_label_new (gettext(prefs_data[i].label_text));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.3);
gtk_widget_show (label);
gtk_table_attach (current_table, label, 0, 1,
row, row + 1,
GTK_FILL | GTK_EXPAND, GTK_FILL, 1, 1);
widget = prefs_get_property_widget(&prefs_data[i]);
if (widget != NULL) {
gtk_table_attach (current_table, widget, 1, 2,
row, row + 1,
GTK_FILL, GTK_FILL, 1, 1);
}
break;
}
prefs_data[i].widget = widget;
}
gtk_widget_show (prefs_dialog);
}
