static gboolean
_dtm_iter_next (GtkTreeModel *tree_model,
GtkTreeIter *iter)
{
int i;
if (NODE_OBJECT(iter)) {
if (!NODE_LAYER(iter))
return FALSE;
i = layer_object_get_index (NODE_LAYER(iter), NODE_OBJECT(iter));
++i;
NODE_OBJECT(iter) = layer_object_get_nth(NODE_LAYER(iter), i);
return NODE_OBJECT(iter) != NULL;
} else if (NODE_LAYER(iter)) {
if (!NODE_DIAGRAM(iter))
return FALSE;
i = data_layer_get_index (NODE_DIAGRAM(iter), NODE_LAYER(iter));
++i;
NODE_LAYER(iter) = data_layer_get_nth(NODE_DIAGRAM(iter), i);
return NODE_LAYER(iter) != NULL;
} else if (NODE_DIAGRAM(iter)) {
GList *list = dia_open_diagrams();
i = g_list_index (list, NODE_DIAGRAM(iter));
++i;
list = g_list_nth (list, i);
NODE_DIAGRAM(iter) = list ? list->data : NULL;
return NODE_DIAGRAM(iter) != NULL;
} else {
/* empy iter? */
GList *list = dia_open_diagrams();
NODE_DIAGRAM(iter) = list ? list->data : NULL;
return NODE_DIAGRAM(iter) != NULL;
}
return FALSE;
}
static gboolean
_dtm_iter_nth_child (GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreeIter *parent,
gint n)
{
if (parent) {
*iter = *parent;
if (NODE_OBJECT(parent)) {
return FALSE;
} else if (NODE_LAYER(parent)) {
NODE_OBJECT(iter) = layer_object_get_nth(NODE_LAYER(iter), n);
return NODE_OBJECT(iter) != NULL;
} else if (NODE_DIAGRAM(parent)) {
NODE_LAYER(iter) = data_layer_get_nth(NODE_DIAGRAM(iter), n);
return NODE_LAYER(iter) != NULL;
}
}
if (!parent || !NODE_DIAGRAM(parent)) {
/* the nth diagram */
GList *list = dia_open_diagrams();
list = g_list_nth(list, n);
NODE_DIAGRAM(iter) = list ? list->data : NULL;
NODE_LAYER(iter) = NULL;
NODE_OBJECT(iter) = NULL;
return NODE_DIAGRAM(iter) != NULL;
}
return FALSE;
}
static int
save_state (GnomeClient *client,
gint phase,
GnomeRestartStyle save_style,
gint shutdown,
GnomeInteractStyle interact_style,
gint fast,
gpointer client_data)
{
gchar *argv[20];
gint i = 0;
GList *l;
Diagram *dia;
argv[i++] = "dia";
for(l = dia_open_diagrams(); l != NULL; l = g_list_next(l)) {
dia = (Diagram *)l->data;
if(!dia->unsaved) {
argv[i++] = dia->filename;
}
}
gnome_client_set_restart_command (client, i, argv);
gnome_client_set_clone_command (client, i, argv);
return TRUE;
}
void
ddisplay_set_all_cursor(GdkCursor *cursor)
{
Diagram *dia;
DDisplay *ddisp;
GList *list;
GSList *slist;
current_cursor = cursor;
list = dia_open_diagrams();
while (list != NULL) {
dia = (Diagram *) list->data;
slist = dia->displays;
while (slist != NULL) {
ddisp = (DDisplay *) slist->data;
ddisplay_set_cursor(ddisp, cursor);
slist = g_slist_next(slist);
}
list = g_list_next(list);
}
}
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);
}
}
void
layer_dialog_set_diagram(Diagram *dia)
{
DiagramData *data;
GtkWidget *layer_widget;
Layer *layer;
Layer *active_layer = NULL;
int sel_pos;
int i,j;
if (dia!=NULL)
active_layer = dia->data->active_layer;
if (layer_dialog == NULL || layer_dialog->dialog == NULL)
layer_dialog_create(); /* May have been destroyed */
g_assert(layer_dialog != NULL); /* must be valid now */
gtk_container_foreach (GTK_CONTAINER(layer_dialog->layer_list),
_layer_widget_clear_layer, NULL);
gtk_list_clear_items(GTK_LIST(layer_dialog->layer_list), 0, -1);
layer_dialog->diagram = dia;
if (dia != NULL) {
i = g_list_index(dia_open_diagrams(), dia);
if (i >= 0 && layer_dialog->diagram_omenu != NULL)
gtk_option_menu_set_history(GTK_OPTION_MENU(layer_dialog->diagram_omenu),
i);
}
if (dia != NULL) {
data = dia->data;
sel_pos = 0;
for (i=data->layers->len-1,j=0;i>=0;i--,j++) {
layer = (Layer *) g_ptr_array_index(data->layers, i);
layer_widget = dia_layer_widget_new(dia, layer);
gtk_widget_show(layer_widget);
gtk_container_add(GTK_CONTAINER(layer_dialog->layer_list), layer_widget);
if (layer==active_layer)
sel_pos = j;
}
gtk_list_select_item(GTK_LIST(layer_dialog->layer_list), sel_pos);
}
}
static void
_dtm_init (DiagramTreeModel *dtm)
{
/* connect to intersting state changes */
g_signal_connect (G_OBJECT (dia_application_get ()),
"diagram_add", G_CALLBACK (_diagram_add), dtm);
g_signal_connect (G_OBJECT (dia_application_get ()),
"diagram_change", G_CALLBACK (_diagram_change), dtm);
g_signal_connect (G_OBJECT(dia_application_get ()),
"diagram_remove", G_CALLBACK (_diagram_remove), dtm);
/* also connect to every already existing diagram */
{
GList *list = dia_open_diagrams();
while (list) {
_dtm_listen_on_diagram (dtm, DIA_DIAGRAM(list->data));
list = g_list_next (list);
}
}
}
static gint
_dtm_iter_n_children (GtkTreeModel *tree_model,
GtkTreeIter *iter)
{
if (!iter)
return g_list_length (dia_open_diagrams());
if (NODE_OBJECT(iter)) {
/* TODO: dive into objects (groups?)? */
return 0;
} else if (NODE_LAYER(iter)) {
if (!NODE_LAYER(iter))
return 0;
return layer_object_count (NODE_LAYER(iter));
} else if (NODE_DIAGRAM(iter)) {
if (!NODE_DIAGRAM(iter))
return 0;
return data_layer_count (NODE_DIAGRAM(iter));
}
return 0;
}
static gboolean
_dtm_iter_children (GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreeIter *parent)
{
if (parent) {
if (NODE_OBJECT(parent))
return FALSE;
else if (NODE_LAYER(parent)) {
NODE_OBJECT(iter) = layer_object_get_nth(NODE_LAYER(parent), 0);
if (NODE_OBJECT(iter)) {
NODE_LAYER(iter) = dia_object_get_parent_layer(NODE_OBJECT(iter));
NODE_DIAGRAM(iter) = layer_get_parent_diagram (NODE_LAYER(iter));
return TRUE;
}
} else if (NODE_DIAGRAM(parent)) {
NODE_LAYER(iter) = data_layer_get_nth(NODE_DIAGRAM(parent), 0);
if (NODE_LAYER(iter)) {
NODE_DIAGRAM(iter) = layer_get_parent_diagram (NODE_LAYER(iter));
NODE_OBJECT(iter) = NULL;
return TRUE;
}
} else {
/* deliver root's children */
parent = NULL;
}
}
if (!parent) {
/* the first diagram */
GList *list = dia_open_diagrams();
NODE_DIAGRAM(iter) = list ? list->data : NULL;
NODE_LAYER(iter) = NULL;
NODE_OBJECT(iter) = NULL;
return NODE_DIAGRAM(iter) != NULL;
}
return FALSE;
}
static GtkTreePath *
_dtm_get_path (GtkTreeModel *tree_model,
GtkTreeIter *iter)
{
GtkTreePath *result;
int index = 0;
if (!NODE_DIAGRAM(iter) && !NODE_LAYER(iter) && !NODE_OBJECT(iter)) {
/* the root path */
return gtk_tree_path_new_first ();
}
result = gtk_tree_path_new ();
if (NODE_DIAGRAM(iter)) {
GList *list = dia_open_diagrams();
gtk_tree_path_append_index (result, g_list_index (list, NODE_DIAGRAM(iter)));
}
if (NODE_LAYER(iter)) {
g_return_val_if_fail (NODE_DIAGRAM(iter) == layer_get_parent_diagram (NODE_LAYER(iter)), NULL);
index = data_layer_get_index (NODE_DIAGRAM(iter), NODE_LAYER(iter));
if (index >= 0)
gtk_tree_path_append_index (result, index);
}
if (index >= 0 && NODE_OBJECT(iter)) {
g_return_val_if_fail (NODE_LAYER(iter) == dia_object_get_parent_layer (NODE_OBJECT(iter)), NULL);
index = layer_object_get_index (NODE_LAYER(iter), NODE_OBJECT(iter));
if (index >= 0)
gtk_tree_path_append_index (result, index);
}
if (index < 0) {
gtk_tree_path_free (result);
return NULL;
}
return result;
}
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);
}
}
static DiaObject *
image_load(ObjectNode obj_node, int version, const char *filename)
{
EImage *image;
Element *elem;
DiaObject *obj;
int i;
AttributeNode attr;
char *diafile_dir;
Diagram *dia;
GList *list;
image = g_malloc0(sizeof(EImage));
elem = &image->element;
obj = &elem->object;
obj->type = &eimage_type;
obj->ops = &eimage_ops;
element_load(elem, obj_node);
image->border_width = 0.1;
attr = object_find_attribute(obj_node, "border_width");
if (attr != NULL)
image->border_width = data_real( attribute_first_data(attr) );
image->border_color = color_black;
attr = object_find_attribute(obj_node, "border_color");
if (attr != NULL)
data_color(attribute_first_data(attr), &image->border_color);
image->line_style = LINESTYLE_SOLID;
attr = object_find_attribute(obj_node, "line_style");
if (attr != NULL)
image->line_style = data_enum( attribute_first_data(attr) );
image->dashlength = DEFAULT_LINESTYLE_DASHLEN;
attr = object_find_attribute(obj_node, "dashlength");
if (attr != NULL)
image->dashlength = data_real(attribute_first_data(attr));
image->draw_border = TRUE;
attr = object_find_attribute(obj_node, "draw_border");
if (attr != NULL)
image->draw_border = data_boolean( attribute_first_data(attr) );
image->keep_aspect = TRUE;
attr = object_find_attribute(obj_node, "keep_aspect");
if (attr != NULL)
image->keep_aspect = data_boolean( attribute_first_data(attr) );
image->keep_orig_aspect = TRUE;
attr = object_find_attribute(obj_node, "keep_orig_aspect");
if (attr != NULL)
image->keep_orig_aspect = data_boolean( attribute_first_data(attr) );
attr = object_find_attribute(obj_node, "file");
if (attr != NULL) {
image->file = data_filename( attribute_first_data(attr) );
} else {
image->file = g_strdup("");
}
attr = object_find_attribute(obj_node, "embed_id");
if (attr) {
image->embed_id =
dtree_conv_longname_from_xml(data_string(attribute_first_data(attr)));
} else {
image->embed_id = get_default_embed_id("embed_image");
}
register_embed_id(image->embed_id);
element_init(elem, 8, NUM_CONNECTIONS);
for (i=0;i<NUM_CONNECTIONS;i++) {
obj->connections[i] = &image->connections[i];
image->connections[i].object = obj;
image->connections[i].connected = NULL;
}
image->connections[8].flags = CP_FLAGS_MAIN;
image->image = NULL;
if (strcmp(image->file, "")!=0) {
diafile_dir = get_directory(filename);
if (g_path_is_absolute(image->file)) { /* Absolute pathname */
image->image = dia_image_load(image->file);
if (image->image == NULL) {
/* Not found as abs path, try in same dir as diagram. */
char *temp_string;
const char *image_file_name = image->file;
const char *psep;
psep = strrchr(image->file, G_DIR_SEPARATOR);
/* try the other G_OS as well */
if (!psep)
psep = strrchr(image->file, G_DIR_SEPARATOR == '/' ? '\\' : '/');
if (psep)
image_file_name = psep + 1;
temp_string = g_build_filename(diafile_dir, image_file_name, NULL);
image->image = dia_image_load(temp_string);
if (image->image != NULL) {
/* Found file in same dir as diagram. */
message_warning(_("The image file '%s' was not found in that directory.\n"
"Using the file '%s' instead\n"), image->file, temp_string);
g_free(image->file);
image->file = temp_string;
} else {
g_free(temp_string);
image->image = dia_image_load((char *)image_file_name);
if (image->image != NULL) {
char *tmp;
/* Found file in current dir. */
message_warning(_("The image file '%s' was not found in that directory.\n"
"Using the file '%s' instead\n"), image->file, image_file_name);
tmp = image->file;
image->file = g_strdup(image_file_name);
g_free(tmp);
} else {
message_warning(_("The image file '%s' was not found.\n"),
image_file_name);
}
}
}
} else { /* Relative pathname: */
char *temp_string;
temp_string = g_build_filename (diafile_dir, image->file, NULL);
image->image = dia_image_load(temp_string);
if (image->image != NULL) {
/* Found file in same dir as diagram. */
g_free(image->file);
image->file = temp_string;
} else {
g_free(temp_string);
image->image = dia_image_load(image->file);
if (image->image == NULL) {
/* Didn't find file in current dir. */
message_warning(_("The image file '%s' was not found.\n"),
image->file);
}
}
}
g_free(diafile_dir);
}
/* update mtime */
{
struct stat st;
if (g_stat (image->file, &st) != 0)
st.st_mtime = 0;
image->mtime = st.st_mtime;
}
image_update_data(image);
obj->node = NULL;
list = dia_open_diagrams();
while (list != NULL) {
dia = (Diagram *)list->data;
if (!g_strcmp0(dia->filename,filename)) {
obj->node = dtree_set_data_by_longname(DIA_DIAGRAM_DATA(dia)->dtree,
image->embed_id,&image->element.object);
}
list = g_list_next(list);
}
return &image->element.object;
}
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");
}
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;
}
