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); } }
Diagram * diagram_load(const char *filename, DiaImportFilter *ifilter) { Diagram *diagram = NULL; GList *diagrams; gboolean was_default = FALSE; for (diagrams = open_diagrams; diagrams != NULL; diagrams = g_list_next(diagrams)) { Diagram *old_diagram = (Diagram*)diagrams->data; if (old_diagram->is_default) { diagram = old_diagram; was_default = TRUE; break; } } /* TODO: Make diagram not be initialized twice */ if (diagram == NULL) { diagram = new_diagram(filename); } if (diagram == NULL) return NULL; if ( !diagram_init(diagram, filename) || !diagram_load_into (diagram, filename, ifilter)) { if (!was_default) /* don't kill the default diagram on import failure */ diagram_destroy(diagram); diagram = NULL; } else { /* not modifying 'diagram->unsaved' the state depends on the import filter used */ diagram_set_modified(diagram, FALSE); if (app_is_interactive()) { recent_file_history_add(filename); if (was_default) /* replacing it is like first remove than add */ dia_diagram_remove(diagram); dia_diagram_add(diagram); } } if (diagram != NULL && was_default && app_is_interactive()) { diagram_update_for_filename(diagram); diagram->is_default = FALSE; if ( g_slist_length(diagram->displays) == 1 ) display_set_active (diagram->displays->data); } return diagram; }
int main(int argc, char *argv[]) { app_init(argc, argv); if (!app_is_interactive()) return 0; toolbox_show(); app_splash_done(); gtk_main (); return 0; }
int _stdcall WinMain (struct HINSTANCE__ *hInstance, struct HINSTANCE__ *hPrevInstance, char *lpszCmdLine, int nCmdShow) { dia_redirect_console (); app_init (__argc, __argv); if (!app_is_interactive()) return 0; toolbox_show(); app_splash_done(); gtk_main (); return 0; }
/** 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; }
/** Initializes a diagram with standard info and sets it to be called * 'filename'. * Returns TRUE if everything went ok, FALSE otherwise. * Will return FALSE if filename is not a legal string in the current * encoding. */ static gboolean diagram_init(Diagram *dia, const char *filename) { gchar *newfilename = NULL; GError *error = NULL; dia->data = &dia->parent_instance; /* compatibility */ dia->pagebreak_color = prefs.new_diagram.pagebreak_color; get_paper_info (&dia->data->paper, -1, &prefs.new_diagram); dia->grid.width_x = prefs.grid.x; dia->grid.width_y = prefs.grid.y; dia->grid.width_w = prefs.grid.w; dia->grid.hex_size = 1.0; dia->grid.colour = prefs.new_diagram.grid_color; dia->grid.hex = prefs.grid.hex; dia->grid.visible_x = prefs.grid.vis_x; dia->grid.visible_y = prefs.grid.vis_y; dia->grid.dynamic = prefs.grid.dynamic; dia->grid.major_lines = prefs.grid.major_lines; dia->guides.nhguides = 0; dia->guides.hguides = NULL; dia->guides.nvguides = 0; dia->guides.vguides = NULL; if (dia->filename != NULL) g_free(dia->filename); /* Make sure the filename is absolute */ if (!g_path_is_absolute(filename)) { gchar *pwd = g_get_current_dir(); newfilename = g_build_filename(pwd, filename, NULL); g_free(pwd); filename = newfilename; } /* All Diagram functions assumes filename in filesystem encoding */ dia->filename = g_filename_to_utf8(filename, -1, NULL, NULL, &error); if (error != NULL) { message_error(_("Couldn't convert filename '%s' to UTF-8: %s\n"), dia_message_filename(filename), error->message); g_error_free(error); dia->filename = g_strdup(_("Error")); return FALSE; } dia->unsaved = TRUE; dia->mollified = FALSE; dia->autosavefilename = NULL; if (dia->undo) undo_destroy(dia->undo); dia->undo = new_undo_stack(dia); if (!g_list_find(open_diagrams, dia)) open_diagrams = g_list_prepend(open_diagrams, dia); if (app_is_interactive()) layer_dialog_update_diagram_list(); g_free(newfilename); g_signal_connect (G_OBJECT(dia), "object_add", G_CALLBACK(_object_add), dia); g_signal_connect (G_OBJECT(dia), "object_remove", G_CALLBACK(_object_remove), dia); return TRUE; }
/** * @param ddisp The diagram display object that a window is created for * @param width Diagram widgth * @param height Diagram Height * @param title Window title * @param use_mbar Flag to indicate whether to add a menubar to the window */ void create_display_shell(DDisplay *ddisp, int width, int height, char *title, int use_mbar) { GtkWidget *table, *widget; GtkWidget *status_hbox; GtkWidget *root_vbox = NULL; GtkWidget *zoom_hbox, *zoom_label; int s_width, s_height; if (app_is_interactive() && is_integrated_ui()) { use_integrated_ui_for_display_shell(ddisp, title); return; } ddisp->is_standalone_window = TRUE; ddisp->container = NULL; s_width = gdk_screen_width (); s_height = gdk_screen_height (); if (width > s_width) width = s_width; if (height > s_height) height = s_height; /* The toplevel shell */ ddisp->shell = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (ddisp->shell), title); gtk_window_set_role (GTK_WINDOW (ddisp->shell), "diagram_window"); gtk_window_set_icon_name (GTK_WINDOW (ddisp->shell), "dia"); gtk_window_set_default_size(GTK_WINDOW (ddisp->shell), width, height); /* set_icon_name needs registered theme icons, not always available: provide fallback */ if (!gtk_window_get_icon (GTK_WINDOW (ddisp->shell))) { static GdkPixbuf *pixbuf = NULL; if (!pixbuf) pixbuf = gdk_pixbuf_new_from_inline(-1, dia_diagram_icon, FALSE, NULL); if (pixbuf) gtk_window_set_icon (GTK_WINDOW (ddisp->shell), pixbuf); } g_object_set_data (G_OBJECT (ddisp->shell), "user_data", (gpointer) ddisp); _ddisplay_setup_events (ddisp, ddisp->shell); /* following two not shared with integrated UI */ g_signal_connect (G_OBJECT (ddisp->shell), "delete_event", G_CALLBACK (ddisplay_delete), ddisp); g_signal_connect (G_OBJECT (ddisp->shell), "destroy", G_CALLBACK (ddisplay_destroy), ddisp); /* the table containing all widgets */ table = gtk_table_new (4, 3, FALSE); gtk_table_set_col_spacing (GTK_TABLE (table), 0, 1); gtk_table_set_col_spacing (GTK_TABLE (table), 1, 2); gtk_table_set_row_spacing (GTK_TABLE (table), 0, 1); gtk_table_set_row_spacing (GTK_TABLE (table), 1, 2); gtk_container_set_border_width (GTK_CONTAINER (table), 2); if (use_mbar) { root_vbox = gtk_vbox_new (FALSE, 1); gtk_container_add (GTK_CONTAINER (ddisp->shell), root_vbox); gtk_box_pack_end (GTK_BOX (root_vbox), table, TRUE, TRUE, 0); } else { gtk_container_add (GTK_CONTAINER (ddisp->shell), table); } /* scrollbars, rulers, canvas, menu popup button */ if (!use_mbar) { ddisp->origin = gtk_button_new(); #if GTK_CHECK_VERSION(2,18,0) gtk_widget_set_can_focus (ddisp->origin, FALSE); #else GTK_WIDGET_UNSET_FLAGS(ddisp->origin, GTK_CAN_FOCUS); #endif widget = gtk_arrow_new(GTK_ARROW_RIGHT, GTK_SHADOW_OUT); gtk_container_add(GTK_CONTAINER(ddisp->origin), widget); gtk_widget_set_tooltip_text(widget, _("Diagram menu.")); gtk_widget_show(widget); g_signal_connect(G_OBJECT(ddisp->origin), "button_press_event", G_CALLBACK(origin_button_press), ddisp); } else { ddisp->origin = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (ddisp->origin), GTK_SHADOW_OUT); } _ddisplay_setup_rulers (ddisp, ddisp->shell, table); _ddisplay_setup_scrollbars (ddisp, table, width, height); _ddisplay_setup_navigation (ddisp, table); ddisp->canvas = create_canvas (ddisp); /* pack all remaining widgets */ gtk_table_attach (GTK_TABLE (table), ddisp->origin, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0); gtk_table_attach (GTK_TABLE (table), ddisp->canvas, 1, 2, 1, 2, GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0); /* TODO rob use per window accel */ ddisp->accel_group = menus_get_display_accels (); gtk_window_add_accel_group(GTK_WINDOW(ddisp->shell), ddisp->accel_group); if (use_mbar) { ddisp->menu_bar = menus_create_display_menubar (&ddisp->ui_manager, &ddisp->actions); g_assert (ddisp->menu_bar); gtk_box_pack_start (GTK_BOX (root_vbox), ddisp->menu_bar, FALSE, TRUE, 0); } /* the statusbars */ status_hbox = gtk_hbox_new (FALSE, 2); /* Zoom status pseudo-optionmenu */ ddisp->zoom_status = create_zoom_widget(ddisp); zoom_hbox = gtk_hbox_new(FALSE, 0); zoom_label = gtk_label_new(_("Zoom")); gtk_box_pack_start (GTK_BOX(zoom_hbox), zoom_label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(zoom_hbox), ddisp->zoom_status, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (status_hbox), zoom_hbox, FALSE, FALSE, 0); /* Grid on/off button */ ddisp->grid_status = dia_toggle_button_new_with_icons(dia_on_grid_icon, dia_off_grid_icon); g_signal_connect(G_OBJECT(ddisp->grid_status), "toggled", G_CALLBACK (grid_toggle_snap), ddisp); gtk_widget_set_tooltip_text(ddisp->grid_status, _("Toggles snap-to-grid for this window.")); gtk_box_pack_start (GTK_BOX (status_hbox), ddisp->grid_status, FALSE, FALSE, 0); ddisp->mainpoint_status = dia_toggle_button_new_with_icons(dia_mainpoints_on_icon, dia_mainpoints_off_icon); g_signal_connect(G_OBJECT(ddisp->mainpoint_status), "toggled", G_CALLBACK (interface_toggle_mainpoint_magnetism), ddisp); gtk_widget_set_tooltip_text(ddisp->mainpoint_status, _("Toggles object snapping for this window.")); gtk_box_pack_start (GTK_BOX (status_hbox), ddisp->mainpoint_status, FALSE, FALSE, 0); /* Statusbar */ ddisp->modified_status = gtk_statusbar_new (); gtk_box_pack_start (GTK_BOX (status_hbox), ddisp->modified_status, TRUE, TRUE, 0); gtk_table_attach (GTK_TABLE (table), status_hbox, 0, 3, 3, 4, GTK_FILL, GTK_FILL, 0, 0); display_rulers_show (ddisp); gtk_widget_show (ddisp->zoom_status); gtk_widget_show (zoom_hbox); gtk_widget_show (zoom_label); gtk_widget_show (ddisp->grid_status); gtk_widget_show (ddisp->mainpoint_status); gtk_widget_show (ddisp->modified_status); gtk_widget_show (status_hbox); gtk_widget_show (table); if (use_mbar) { gtk_widget_show (ddisp->menu_bar); gtk_widget_show (root_vbox); } gtk_widget_show (ddisp->shell); /* before showing up, checking canvas's REAL size */ if (use_mbar && ddisp->hrule->allocation.width > width) { /* The menubar is not shrinkable, so the shell will have at least * the menubar's width. If the diagram's requested width is smaller, * the canvas will be enlarged to fit the place. In this case, we * need to adjust the horizontal scrollbar according to the size * that will be allocated, which the same as the hrule got. */ width = ddisp->hrule->allocation.width; gtk_adjustment_set_upper (ddisp->hsbdata, width); gtk_adjustment_set_page_increment (ddisp->hsbdata, (width - 1) / 4); gtk_adjustment_set_page_size (ddisp->hsbdata, width - 1); gtk_adjustment_changed (GTK_ADJUSTMENT(ddisp->hsbdata)); } gtk_widget_show (ddisp->canvas); /* set the focus to the canvas area */ gtk_widget_grab_focus (ddisp->canvas); }