static void
layer_change_revert(struct LayerChange *change, Diagram *dia)
{
switch (change->type) {
case TYPE_DELETE_LAYER:
data_add_layer_at(dia->data, change->layer, change->index);
break;
case TYPE_ADD_LAYER:
data_remove_layer(dia->data, change->layer);
break;
case TYPE_RAISE_LAYER:
data_lower_layer(dia->data, change->layer);
break;
case TYPE_LOWER_LAYER:
data_raise_layer(dia->data, change->layer);
break;
}
diagram_add_update_all(dia);
if (layer_dialog->diagram == dia) {
layer_dialog_set_diagram(dia);
}
change->applied = 0;
}
static void
layer_dialog_select_diagram_callback(GtkWidget *widget, gpointer gdata)
{
Diagram *dia = (Diagram *) gdata;
layer_dialog_set_diagram(dia);
}
static void
edit_layer_add_ok_callback (GtkWidget *w, gpointer client_data)
{
EditLayerDialog *dialog = (EditLayerDialog *) client_data;
Diagram *dia = ddisplay_active_diagram();
Layer *layer;
int pos = data_layer_get_index (dia->data, dia->data->active_layer) + 1;
layer = new_layer(g_strdup (gtk_entry_get_text (GTK_ENTRY (dialog->name_entry))), dia->data);
data_add_layer_at(dia->data, layer, pos);
data_set_active_layer(dia->data, layer);
diagram_add_update_all(dia);
diagram_flush(dia);
undo_layer(dia, layer, TYPE_ADD_LAYER, pos);
undo_set_transactionpoint(dia->undo);
/* ugly way of updating the layer widget */
if (layer_dialog && layer_dialog->diagram == dia) {
layer_dialog_set_diagram(dia);
}
gtk_widget_destroy (dialog->dialog);
g_free (dialog);
}
/**
* Respond to the user finishing the Open Dialog either accept or cancel/destroy
*/
static void
file_open_response_callback(GtkWidget *fs,
gint response,
gpointer user_data)
{
char *filename;
Diagram *diagram = NULL;
if (response == GTK_RESPONSE_ACCEPT) {
gint index = gtk_combo_box_get_active (GTK_COMBO_BOX(user_data));
if (index >= 0) /* remember it */
persistence_set_integer ("import-filter", index);
filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(fs));
diagram = diagram_load(filename, ifilter_by_index (index - 1, filename));
g_free (filename);
if (diagram != NULL) {
diagram_update_extents(diagram);
layer_dialog_set_diagram(diagram);
if (diagram->displays == NULL) {
/* GSList *displays = diagram->displays;
GSList *displays_head = displays;
diagram->displays = NULL;
for (; displays != NULL; displays = g_slist_next(displays)) {
DDisplay *loaded_display = (DDisplay *)displays->data;
copy_display(loaded_display);
g_free(loaded_display);
}
g_slist_free(displays_head);
} else {
*/
new_display(diagram);
}
}
}
gtk_widget_destroy(opendlg);
}
static void
layer_visibility_change_apply(struct LayerVisibilityChange *change,
Diagram *dia)
{
GPtrArray *layers;
Layer *layer = change->layer;
int visible = FALSE;
int i;
if (change->is_exclusive) {
/* First determine if _any_ other layer widgets are set to visible.
* If there is, exclusive switching turns all off. */
for (i=0;i<dia->data->layers->len;i++) {
Layer *temp_layer = g_ptr_array_index(dia->data->layers, i);
if (temp_layer != layer) {
visible |= temp_layer->visible;
}
}
/* Now, toggle the visibility for all layers except the specified one */
layers = dia->data->layers;
for (i = 0; i < layers->len; i++) {
Layer *temp_layer = (Layer *) g_ptr_array_index(layers, i);
if (temp_layer == layer) {
temp_layer->visible = TRUE;
} else {
temp_layer->visible = !visible;
}
}
} else {
layer->visible = !layer->visible;
}
diagram_add_update_all(dia);
if (layer_dialog->diagram == dia) {
layer_dialog_set_diagram(dia);
}
}
static void
edit_layer_rename_ok_callback (GtkWidget *w, gpointer client_data)
{
EditLayerDialog *dialog = (EditLayerDialog *) client_data;
Diagram *dia = ddisplay_active_diagram();
Layer *layer = dia->data->active_layer;
g_free (layer->name);
layer->name = g_strdup (gtk_entry_get_text (GTK_ENTRY (dialog->name_entry)));
diagram_add_update_all(dia);
diagram_flush(dia);
/* FIXME: undo handling */
/* ugly way of updating the layer widget */
if (layer_dialog && layer_dialog->diagram == dia) {
layer_dialog_set_diagram(dia);
}
gtk_widget_destroy (dialog->dialog);
g_free (dialog);
}
/** Revert to the visibility before this change was applied.
*/
static void
layer_visibility_change_revert(struct LayerVisibilityChange *change,
Diagram *dia)
{
GList *vis = change->original_visibility;
GPtrArray *layers = dia->data->layers;
int i;
for (i = 0; vis != NULL && i < layers->len; vis = g_list_next(vis), i++) {
Layer *layer = (Layer*) g_ptr_array_index(layers, i);
layer->visible = (gboolean)vis->data;
}
if (vis != NULL || i < layers->len) {
printf("Internal error: visibility undo has %d visibilities, but %d layers\n",
g_list_length(change->original_visibility), layers->len);
}
diagram_add_update_all(dia);
if (layer_dialog->diagram == dia) {
layer_dialog_set_diagram(dia);
}
}
void
layer_dialog_update_diagram_list(void)
{
GtkWidget *new_menu;
GtkWidget *menu_item;
GList *dia_list;
Diagram *dia;
char *filename;
int i;
int current_nr;
if (layer_dialog == NULL || layer_dialog->dialog == NULL) {
if (!dia_open_diagrams())
return; /* shortcut; maybe session end w/o this dialog */
else
layer_dialog_create();
}
g_assert(layer_dialog != NULL); /* must be valid now */
/* oh this options: here integrated UI ;( */
if (!layer_dialog->diagram_omenu)
return;
new_menu = gtk_menu_new();
current_nr = -1;
i = 0;
dia_list = dia_open_diagrams();
while (dia_list != NULL) {
dia = (Diagram *) dia_list->data;
if (dia == layer_dialog->diagram) {
current_nr = i;
}
filename = strrchr(dia->filename, G_DIR_SEPARATOR);
if (filename==NULL) {
filename = dia->filename;
} else {
filename++;
}
menu_item = gtk_menu_item_new_with_label(filename);
g_signal_connect (G_OBJECT (menu_item), "activate",
G_CALLBACK (layer_dialog_select_diagram_callback), dia);
gtk_menu_append( GTK_MENU(new_menu), menu_item);
gtk_widget_show (menu_item);
dia_list = g_list_next(dia_list);
i++;
}
if (dia_open_diagrams()==NULL) {
menu_item = gtk_menu_item_new_with_label (_("none"));
g_signal_connect (G_OBJECT (menu_item), "activate",
G_CALLBACK (layer_dialog_select_diagram_callback), NULL);
gtk_menu_append( GTK_MENU(new_menu), menu_item);
gtk_widget_show (menu_item);
}
gtk_option_menu_remove_menu(GTK_OPTION_MENU(layer_dialog->diagram_omenu));
gtk_option_menu_set_menu(GTK_OPTION_MENU(layer_dialog->diagram_omenu),
new_menu);
gtk_option_menu_set_history(GTK_OPTION_MENU(layer_dialog->diagram_omenu),
current_nr);
gtk_menu_set_active(GTK_MENU(new_menu), current_nr);
if (current_nr == -1) {
dia = NULL;
if (dia_open_diagrams()!=NULL) {
dia = (Diagram *) dia_open_diagrams()->data;
}
layer_dialog_set_diagram(dia);
}
}
void
app_init (int argc, char **argv)
{
static gboolean nosplash = FALSE;
static gboolean nonew = FALSE;
static gboolean use_integrated_ui = TRUE;
static gboolean credits = FALSE;
static gboolean version = FALSE;
static gboolean verbose = FALSE;
static gboolean log_to_stderr = FALSE;
#ifdef HAVE_GNOME
GnomeClient *client;
#endif
static char *export_file_name = NULL;
static char *export_file_format = NULL;
static char *size = NULL;
static char *show_layers = NULL;
gboolean made_conversions = FALSE;
GSList *files = NULL;
static const gchar **filenames = NULL;
int i = 0;
gchar *export_format_string =
/* Translators: The argument is a list of options, not to be translated */
g_strdup_printf(_("Select the filter/format out of: %s"),
"cgm, dia, dxf, eps, eps-builtin, " EPS_PANGO
"fig, mp, plt, hpgl, png ("
# if defined(HAVE_LIBPNG) && defined(HAVE_LIBART)
"png-libart, "
# endif
# ifdef HAVE_CAIRO
"cairo-png, cairo-alpha-png, "
# endif
/* we always have pixbuf but don't know exactly all it's *few* save formats */
"pixbuf-png), jpg, "
"shape, svg, tex (pgf-tex, pstricks-tex), " WMF
"wpg");
GOptionContext *context = NULL;
static GOptionEntry options[] =
{
{"export", 'e', 0, G_OPTION_ARG_FILENAME, NULL /* &export_file_name */,
N_("Export loaded file and exit"), N_("OUTPUT")},
{"filter",'t', 0, G_OPTION_ARG_STRING, NULL /* &export_file_format */,
NULL /* &export_format_string */, N_("TYPE") },
{"size", 's', 0, G_OPTION_ARG_STRING, NULL,
N_("Export graphics size"), N_("WxH")},
{"show-layers", 'L', 0, G_OPTION_ARG_STRING, NULL,
N_("Show only specified layers (e.g. when exporting). Can be either the layer name or a range of layer numbers (X-Y)"),
N_("LAYER,LAYER,...")},
{"nosplash", 'n', 0, G_OPTION_ARG_NONE, &nosplash,
N_("Don't show the splash screen"), NULL },
{"nonew", 'n', 0, G_OPTION_ARG_NONE, &nonew,
N_("Don't create an empty diagram"), NULL },
{"classic", '\0', G_OPTION_FLAG_REVERSE, G_OPTION_ARG_NONE, &use_integrated_ui,
N_("Start classic user interface (no diagrams in tabs)"), NULL },
{"log-to-stderr", 'l', 0, G_OPTION_ARG_NONE, &log_to_stderr,
N_("Send error messages to stderr instead of showing dialogs."), NULL },
{"input-directory", 'I', 0, G_OPTION_ARG_CALLBACK, _check_option_input_directory,
N_("Directory containing input files"), N_("DIRECTORY")},
{"output-directory", 'O', 0, G_OPTION_ARG_CALLBACK, _check_option_output_directory,
N_("Directory containing output files"), N_("DIRECTORY")},
{"credits", 'c', 0, G_OPTION_ARG_NONE, &credits,
N_("Display credits list and exit"), NULL },
{"verbose", 0, 0, G_OPTION_ARG_NONE, &verbose,
N_("Generate verbose output"), NULL },
{"version", 'v', 0, G_OPTION_ARG_NONE, &version,
N_("Display version and exit"), NULL },
{ G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_FILENAME_ARRAY, NULL /* &filenames */,
NULL, NULL },
{ NULL }
};
/* for users of app_init() the default is interactive */
dia_is_interactive = TRUE;
options[0].arg_data = &export_file_name;
options[1].arg_data = &export_file_format;
options[1].description = export_format_string;
options[2].arg_data = &size;
options[3].arg_data = &show_layers;
g_assert (strcmp (options[13].long_name, G_OPTION_REMAINING) == 0);
options[13].arg_data = (void*)&filenames;
argv0 = (argc > 0) ? argv[0] : "(none)";
#if GTK_CHECK_VERSION(2,24,0)
/* ... use setlocale directly? */
#else
gtk_set_locale();
#endif
setlocale(LC_NUMERIC, "C");
_setup_textdomains ();
context = g_option_context_new(_("[FILE...]"));
g_option_context_add_main_entries (context, options, GETTEXT_PACKAGE);
#ifndef HAVE_GNOME
/* avoid to add it a second time */
g_option_context_add_group (context, gtk_get_option_group (FALSE));
#endif
if (argv) {
GError *error = NULL;
if (!g_option_context_parse (context, &argc, &argv, &error)) {
if (error) { /* IMO !error here is a bug upstream, triggered e.g. with --gdk-debug=updates */
g_print ("%s", error->message);
g_error_free (error);
} else {
g_print (_("Invalid option?"));
}
g_option_context_free(context);
exit(1);
}
/* second level check of command line options, existance of input files etc. */
if (filenames) {
while (filenames[i] != NULL) {
gchar *filename;
gchar *testpath;
if (g_str_has_prefix (filenames[i], "file://")) {
filename = g_filename_from_uri (filenames[i], NULL, NULL);
if (!g_utf8_validate(filename, -1, NULL)) {
gchar *tfn = filename;
filename = g_filename_to_utf8(filename, -1, NULL, NULL, NULL);
g_free(tfn);
}
} else
filename = g_filename_to_utf8 (filenames[i], -1, NULL, NULL, NULL);
if (!filename) {
g_print (_("Filename conversion failed: %s\n"), filenames[i]);
continue;
}
if (g_path_is_absolute(filename))
testpath = filename;
else
testpath = g_build_filename(input_directory ? input_directory : ".", filename, NULL);
/* we still have a problem here, if GLib's file name encoding would not be utf-8 */
if (g_file_test (testpath, G_FILE_TEST_IS_REGULAR))
files = g_slist_append(files, filename);
else {
g_print (_("Missing input: %s\n"), filename);
g_free (filename);
}
if (filename != testpath)
g_free (testpath);
++i;
}
}
/* given some files to output, we are not starting up the UI */
if (export_file_name || export_file_format || size)
dia_is_interactive = FALSE;
}
if (argv && dia_is_interactive && !version) {
#ifdef HAVE_GNOME
GnomeProgram *program =
gnome_program_init (PACKAGE, VERSION, LIBGNOMEUI_MODULE,
argc, argv,
/* haven't found a quick way to pass GOption here */
GNOME_PARAM_GOPTION_CONTEXT, context,
GNOME_PROGRAM_STANDARD_PROPERTIES,
GNOME_PARAM_NONE);
client = gnome_master_client();
if(client == NULL) {
g_warning(_("Can't connect to session manager!\n"));
}
else {
g_signal_connect(G_OBJECT (client), "save_yourself",
G_CALLBACK (save_state), NULL);
g_signal_connect(G_OBJECT (client), "die",
G_CALLBACK (session_die), NULL);
}
/* This smaller icon is 48x48, standard Gnome size */
/* gnome_window_icon_set_default_from_file (GNOME_ICONDIR"/dia_gnome_icon.png");*/
#else
# ifdef G_THREADS_ENABLED
g_thread_init (NULL);
# endif
gtk_init(&argc, &argv);
#endif
}
else {
#ifdef G_THREADS_ENABLED
g_thread_init (NULL);
#endif
g_type_init();
/*
* On Windows there is no command line without display so that gtk_init is harmless.
* On X11 we need gtk_init_check() to avoid exit() just because there is no display
* running outside of X11.
*/
if (!gtk_init_check(&argc, &argv))
dia_log_message ("Running without display");
}
/* done with option parsing, don't leak */
g_free(export_format_string);
if (version) {
gchar *ver_utf8;
gchar *ver_locale;
#if (defined __TIME__) && (defined __DATE__)
/* TRANSLATOR: 2nd and 3rd %s are time and date respectively. */
ver_utf8 = g_strdup_printf(_("Dia version %s, compiled %s %s\n"), VERSION, __TIME__, __DATE__);
#else
ver_utf8 = g_strdup_printf(_("Dia version %s\n"), VERSION);
#endif
ver_locale = g_locale_from_utf8(ver_utf8, -1, NULL, NULL, NULL);
printf("%s\n", ver_locale);
g_free(ver_locale);
g_free(ver_utf8);
if (verbose)
dump_dependencies();
exit(0);
}
if (!dia_is_interactive)
log_to_stderr = TRUE;
libdia_init ( (dia_is_interactive ? DIA_INTERACTIVE : 0)
| (log_to_stderr ? DIA_MESSAGE_STDERR : 0)
| (verbose ? DIA_VERBOSE : 0) );
print_credits(credits);
if (dia_is_interactive) {
create_user_dirs();
if (!nosplash)
app_splash_init("");
/* Init cursors: */
default_cursor = gdk_cursor_new(GDK_LEFT_PTR);
ddisplay_set_all_cursor(default_cursor);
}
dia_register_plugins();
dia_register_builtin_plugin(internal_plugin_init);
load_all_sheets(); /* new mechanism */
dia_log_message ("object defaults");
{
DiaContext *ctx = dia_context_new (_("Object Defaults"));
dia_object_defaults_load (NULL, TRUE /* prefs.object_defaults_create_lazy */, ctx);
dia_context_release (ctx);
}
debug_break();
if (object_get_type("Standard - Box") == NULL) {
message_error(_("Couldn't find standard objects when looking for "
"object-libs; exiting...\n"));
g_critical( _("Couldn't find standard objects when looking for "
"object-libs in '%s'; exiting...\n"), dia_get_lib_directory("dia"));
exit(1);
}
persistence_load();
/** Must load prefs after persistence */
prefs_init();
if (dia_is_interactive) {
/* further initialization *before* reading files */
active_tool = create_modify_tool();
dia_log_message ("ui creation");
if (use_integrated_ui) {
create_integrated_ui();
} else {
create_toolbox();
/* for the integrated ui case it is integrated */
persistence_register_window_create("layer_window",
(NullaryFunc*)&layer_dialog_create);
}
/*fill recent file menu */
recent_file_history_init();
/* Set up autosave to check every 5 minutes */
g_timeout_add_seconds(5*60, autosave_check_autosave, NULL);
#if 0 /* do we really open these automatically in the next session? */
persistence_register_window_create("diagram_tree",
&diagram_tree_show);
#endif
persistence_register_window_create("sheets_main_dialog",
(NullaryFunc*)&sheets_dialog_create);
/* In current setup, we can't find the autosaved files. */
/*autosave_restore_documents();*/
}
dia_log_message ("diagrams");
made_conversions = handle_all_diagrams(files, export_file_name,
export_file_format, size, show_layers,
input_directory, output_directory);
if (dia_is_interactive && files == NULL && !nonew) {
if (use_integrated_ui) {
GList * list;
file_new_callback(NULL);
list = dia_open_diagrams();
if (list) {
Diagram * diagram = list->data;
diagram_update_extents(diagram);
diagram->is_default = TRUE;
}
} else {
gchar *filename = g_filename_from_utf8(_("Diagram1.dia"), -1, NULL, NULL, NULL);
Diagram *diagram = new_diagram (filename);
g_free(filename);
if (diagram != NULL) {
diagram_update_extents(diagram);
diagram->is_default = TRUE;
/* I think this is done in diagram_init() with a call to
* layer_dialog_update_diagram_list() */
layer_dialog_set_diagram(diagram);
new_display(diagram);
}
}
}
g_slist_free(files);
if (made_conversions) exit(0);
dynobj_refresh_init();
dia_log_message ("initialized");
}
/** Handle loading of diagrams given on command line, including conversions.
* Returns TRUE if any automatic conversions were performed.
* Note to future hackers: 'size' is currently the only argument that can be
* sent to exporters. If more arguments are desired, please don't just add
* even more arguments, but create a more general system.
*/
static gboolean
handle_initial_diagram(const char *in_file_name,
const char *out_file_name,
const char *export_file_format,
const char *size,
char* show_layers,
const char *outdir) {
Diagram *diagram = NULL;
gboolean made_conversions = FALSE;
if (export_file_format) {
char *export_file_name = NULL;
DiaExportFilter *ef = NULL;
/* First try guessing based on extension */
export_file_name = build_output_file_name(in_file_name, export_file_format, outdir);
/* to make the --size hack even uglier but work again for the only filter supporting it */
if ( size && strcmp(export_file_format, "png") == 0)
ef = filter_export_get_by_name ("png-libart");
if (!ef)
ef = filter_guess_export_filter(export_file_name);
if (ef == NULL) {
ef = filter_export_get_by_name(export_file_format);
if (ef == NULL) {
g_critical(_("Can't find output format/filter %s\n"), export_file_format);
return FALSE;
}
g_free (export_file_name);
export_file_name = build_output_file_name(in_file_name, ef->extensions[0], outdir);
}
made_conversions |= do_convert(in_file_name,
(out_file_name != NULL?out_file_name:export_file_name),
ef, size, show_layers);
g_free(export_file_name);
} else if (out_file_name) {
DiaExportFilter *ef = NULL;
/* if this looks like an ugly hack to you, agreed ;) */
if (size && strstr(out_file_name, ".png"))
ef = filter_export_get_by_name ("png-libart");
made_conversions |= do_convert(in_file_name, out_file_name, ef,
size, show_layers);
} else {
if (g_file_test(in_file_name, G_FILE_TEST_EXISTS)) {
diagram = diagram_load (in_file_name, NULL);
} else {
diagram = new_diagram (in_file_name);
}
if (diagram != NULL) {
diagram_update_extents(diagram);
if (app_is_interactive()) {
layer_dialog_set_diagram(diagram);
/* the display initial diagram holds two references */
new_display(diagram);
} else {
g_object_unref(diagram);
}
}
}
return made_conversions;
}
static void
dia_dnd_file_drag_data_received (GtkWidget *widget,
GdkDragContext *context,
gint x,
gint y,
GtkSelectionData *data,
guint info,
guint time,
DDisplay *ddisp)
{
#if GTK_CHECK_VERSION(2,22,0)
switch (gdk_drag_context_get_selected_action(context))
#else
switch (context->action)
#endif
{
case GDK_ACTION_DEFAULT:
case GDK_ACTION_COPY:
case GDK_ACTION_MOVE:
case GDK_ACTION_LINK:
case GDK_ACTION_ASK:
default:
{
Diagram *diagram = NULL;
gchar *sPath = NULL, *pFrom, *pTo;
pFrom = strstr((gchar *) gtk_selection_data_get_data(data), "file:");
while (pFrom) {
GError *error = NULL;
pTo = pFrom;
while (*pTo != 0 && *pTo != 0xd && *pTo != 0xa) pTo ++;
sPath = g_strndup(pFrom, pTo - pFrom);
/* format changed with Gtk+2.0, use conversion */
pFrom = g_filename_from_uri (sPath, NULL, &error);
if (!ddisp)
diagram = diagram_load (pFrom, NULL);
else {
diagram = ddisp->diagram;
if (!diagram_load_into (diagram, pFrom, NULL)) {
/* the import filter is supposed to show the error message */
gtk_drag_finish (context, TRUE, FALSE, time);
break;
}
}
g_free (pFrom);
g_free(sPath);
if (diagram != NULL) {
diagram_update_extents(diagram);
layer_dialog_set_diagram(diagram);
if (diagram->displays == NULL) {
new_display(diagram);
}
}
pFrom = strstr(pTo, "file:");
} /* while */
gtk_drag_finish (context, TRUE, FALSE, time);
}
break;
}
return;
}
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);
}
}
}
