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