logdiag/src/ld-window-main.c

1269 lines
36 KiB
C

/*
* ld-window-main.c
*
* This file is a part of logdiag.
* Copyright 2010 - 2021 Přemysl Eric Janouch
*
* See the file LICENSE for licensing information.
*
*/
#include <liblogdiag/liblogdiag.h>
#include "config.h"
#include "ld-window-main.h"
#ifdef G_OS_WIN32
#include <gdk/gdkwin32.h>
#include <shellapi.h>
#endif
struct _LdWindowMainPrivate
{
GSettings *settings;
GtkUIManager *ui_manager;
GtkActionGroup *action_group;
GtkWidget *vbox;
GtkWidget *paned;
GtkWidget *menu;
GtkWidget *toolbar;
GtkWidget *library_view;
GtkWidget *lv_window;
GtkWidget *lv_viewport;
LdLibrary *library;
LdDiagram *diagram;
gchar *filename;
GtkWidget *scrolled_window;
LdDiagramView *view;
GtkWidget *statusbar;
GtkWidget *zoom_label;
guint statusbar_symbol_context_id;
guint statusbar_menu_context_id;
guint statusbar_hint_context_id;
guint statusbar_hint_drag;
};
/* ===== Local functions =================================================== */
static void ld_window_main_finalize (GObject *gobject);
static void load_library_directories (LdLibrary *library);
static void display_and_free_error (LdWindowMain *self, const gchar *title,
GError *error);
static void on_ui_proxy_connected (GtkUIManager *ui, GtkAction *action,
GtkWidget *proxy, LdWindowMain *window);
static void on_ui_proxy_disconnected (GtkUIManager *ui, GtkAction *action,
GtkWidget *proxy, LdWindowMain *window);
static void on_menu_item_selected (GtkWidget *item, LdWindowMain *window);
static void on_menu_item_deselected (GtkMenuItem *item, LdWindowMain *window);
static gboolean on_delete (LdWindowMain *self, GdkEvent *event,
gpointer user_data);
static void update_title (LdWindowMain *self);
static void action_set_sensitive (LdWindowMain *self, const gchar *name,
gboolean sensitive);
static void on_view_zoom_changed (LdDiagramView *view,
GParamSpec *pspec, LdWindowMain *self);
static void on_diagram_changed (LdDiagram *diagram, LdWindowMain *self);
static void on_diagram_history_changed (LdDiagram *diagram,
GParamSpec *pspec, LdWindowMain *self);
static void on_diagram_selection_changed (LdDiagram *diagram,
LdWindowMain *self);
static gchar *diagram_get_name (LdWindowMain *self);
static void diagram_set_filename (LdWindowMain *self, gchar *filename);
static void diagram_new (LdWindowMain *self);
static gboolean diagram_open (LdWindowMain *self, const gchar *filename);
static gboolean diagram_save (LdWindowMain *self, GtkWindow *dialog_parent,
const gchar *filename);
static GtkFileFilter *diagram_get_file_filter (void);
static void diagram_show_open_dialog (LdWindowMain *self);
static void diagram_show_save_as_dialog (LdWindowMain *self);
static gboolean may_close_diagram (LdWindowMain *self,
const gchar *dialog_message);
static gboolean may_quit (LdWindowMain *self);
static void on_symbol_selected (LdCategoryView *view,
LdSymbol *symbol, const gchar *path, LdWindowMain *self);
static void on_symbol_deselected (LdCategoryView *view,
LdSymbol *symbol, const gchar *path, LdWindowMain *self);
static void on_action_new (GtkAction *action, LdWindowMain *self);
static void on_action_open (GtkAction *action, LdWindowMain *self);
static void on_action_save (GtkAction *action, LdWindowMain *self);
static void on_action_save_as (GtkAction *action, LdWindowMain *self);
static void on_action_print (GtkAction *action, LdWindowMain *self);
static void on_action_print_draw_page (GtkPrintOperation *operation,
GtkPrintContext *context, int page_nr, LdWindowMain *self);
static void on_action_quit (GtkAction *action, LdWindowMain *self);
static void on_action_user_guide (GtkAction *action, LdWindowMain *self);
static void on_action_about (GtkAction *action, LdWindowMain *self);
static gboolean on_action_about_activate_link (GtkAboutDialog *dialog,
gchar *uri, LdWindowMain *self);
static void on_action_undo (GtkAction *action, LdWindowMain *self);
static void on_action_redo (GtkAction *action, LdWindowMain *self);
static void on_action_delete (GtkAction *action, LdWindowMain *self);
static void on_action_select_all (GtkAction *action, LdWindowMain *self);
static void on_action_main_toolbar (GtkToggleAction *action,
LdWindowMain *self);
static void on_action_library_pane (GtkToggleAction *action,
LdWindowMain *self);
static void on_action_grid (GtkToggleAction *action, LdWindowMain *self);
static void on_action_zoom_in (GtkAction *action, LdWindowMain *self);
static void on_action_zoom_out (GtkAction *action, LdWindowMain *self);
static void on_action_normal_size (GtkAction *action, LdWindowMain *self);
/* ===== Local variables =================================================== */
/* Actions for menus, toolbars, accelerators. */
static GtkActionEntry wm_action_entries[] =
{
{"FileMenu", NULL, N_("_File"), NULL, NULL, NULL},
{"New", GTK_STOCK_NEW, N_("_New"), "<Ctrl>N",
N_("Create a new diagram"),
G_CALLBACK (on_action_new)},
{"Open", GTK_STOCK_OPEN, N_("_Open..."), "<Ctrl>O",
N_("Open a diagram"),
G_CALLBACK (on_action_open)},
{"Save", GTK_STOCK_SAVE, N_("_Save"), "<Ctrl>S",
N_("Save the current diagram"),
G_CALLBACK (on_action_save)},
{"SaveAs", GTK_STOCK_SAVE_AS, N_("Save _As..."), "<Shift><Ctrl>S",
N_("Save the current diagram with another name"),
G_CALLBACK (on_action_save_as)},
{"Print", GTK_STOCK_PRINT, N_("_Print..."), "<Ctrl>P",
N_("Print the diagram"),
G_CALLBACK (on_action_print)},
{"Quit", GTK_STOCK_QUIT, N_("_Quit"), "<Ctrl>Q",
N_("Quit the application"),
G_CALLBACK (on_action_quit)},
{"EditMenu", NULL, N_("_Edit"), NULL, NULL, NULL},
{"Undo", GTK_STOCK_UNDO, N_("_Undo"), "<Ctrl>Z",
N_("Undo the last action"),
G_CALLBACK (on_action_undo)},
{"Redo", GTK_STOCK_REDO, N_("_Redo"), "<Shift><Ctrl>Z",
N_("Redo the last undone action"),
G_CALLBACK (on_action_redo)},
/*
* {"Cut", GTK_STOCK_CUT, N_("Cu_t"), "<Ctrl>X", NULL, NULL},
* {"Copy", GTK_STOCK_COPY, N_("_Copy"), "<Ctrl>C", NULL, NULL},
* {"Paste", GTK_STOCK_PASTE, N_("_Paste"), "<Ctrl>V", NULL, NULL},
*/
{"Delete", GTK_STOCK_DELETE, N_("_Delete"), "Delete",
N_("Delete the contents of the selection"),
G_CALLBACK (on_action_delete)},
{"SelectAll", GTK_STOCK_SELECT_ALL, N_("Select _All"), "<Ctrl>A",
N_("Select all objects in the diagram"),
G_CALLBACK (on_action_select_all)},
{"ViewMenu", NULL, N_("_View"), NULL, NULL, NULL},
{"ZoomIn", GTK_STOCK_ZOOM_IN, N_("_Zoom In"), "<Ctrl>plus",
N_("Zoom into the diagram"),
G_CALLBACK (on_action_zoom_in)},
{"ZoomOut", GTK_STOCK_ZOOM_OUT, N_("Zoom _Out"), "<Ctrl>minus",
N_("Zoom out of the diagram"),
G_CALLBACK (on_action_zoom_out)},
{"NormalSize", GTK_STOCK_ZOOM_100, N_("_Normal Size"), "<Ctrl>0",
N_("Reset zoom level back to the default"),
G_CALLBACK (on_action_normal_size)},
{"HelpMenu", NULL, N_("_Help"), NULL, NULL, NULL},
{"UserGuide", GTK_STOCK_HELP, N_("_User Guide"), NULL,
N_("Open the manual"),
G_CALLBACK (on_action_user_guide)},
{"About", GTK_STOCK_ABOUT, N_("_About"), NULL,
N_("Show a dialog about this application"),
G_CALLBACK (on_action_about)},
};
static GtkToggleActionEntry wm_toggle_action_entries[] =
{
{"MainToolbar", NULL, N_("_Main Toolbar"), NULL,
N_("Toggle displaying of the main toolbar"),
G_CALLBACK (on_action_main_toolbar), TRUE},
{"LibraryPane", NULL, N_("_Library Pane"), NULL,
N_("Toggle displaying of the library pane"),
G_CALLBACK (on_action_library_pane), TRUE},
{"ShowGrid", NULL, N_("Show _Grid"), "numbersign",
N_("Toggle displaying of the grid"),
G_CALLBACK (on_action_grid), TRUE}
};
/* ===== Generic widget methods ============================================ */
/**
* ld_window_main_new:
* @filename: (allow-none): a file to open.
*
* Create an instance.
*/
GtkWidget *
ld_window_main_new (const gchar *filename)
{
GtkWidget *self;
self = g_object_new (LD_TYPE_WINDOW_MAIN, NULL);
if (filename)
diagram_open (LD_WINDOW_MAIN (self), filename);
return self;
}
G_DEFINE_TYPE (LdWindowMain, ld_window_main, GTK_TYPE_WINDOW)
static void
ld_window_main_class_init (LdWindowMainClass *klass)
{
GObjectClass *object_class;
object_class = G_OBJECT_CLASS (klass);
object_class->finalize = ld_window_main_finalize;
g_type_class_add_private (klass, sizeof (LdWindowMainPrivate));
}
static void
ld_window_main_init (LdWindowMain *self)
{
LdWindowMainPrivate *priv;
GError *error;
self->priv = priv = G_TYPE_INSTANCE_GET_PRIVATE
(self, LD_TYPE_WINDOW_MAIN, LdWindowMainPrivate);
/* Construct menu and toolbar. */
priv->ui_manager = gtk_ui_manager_new ();
g_signal_connect (priv->ui_manager, "connect-proxy",
G_CALLBACK (on_ui_proxy_connected), self);
g_signal_connect (priv->ui_manager, "disconnect-proxy",
G_CALLBACK (on_ui_proxy_disconnected), self);
priv->action_group = gtk_action_group_new ("MainActions");
gtk_action_group_set_translation_domain
(priv->action_group, GETTEXT_DOMAIN);
gtk_action_group_add_actions
(priv->action_group, wm_action_entries,
G_N_ELEMENTS (wm_action_entries), self);
gtk_action_group_add_toggle_actions
(priv->action_group, wm_toggle_action_entries,
G_N_ELEMENTS (wm_toggle_action_entries), self);
gtk_ui_manager_insert_action_group (priv->ui_manager,
priv->action_group, 0);
error = NULL;
gtk_ui_manager_add_ui_from_resource
(priv->ui_manager, "/logdiag/logdiag.ui", &error);
if (error)
{
g_message ("building UI failed: %s", error->message);
g_error_free (error);
}
priv->menu = gtk_ui_manager_get_widget (priv->ui_manager, "/MenuBar");
priv->toolbar = gtk_ui_manager_get_widget (priv->ui_manager, "/Toolbar");
/* Create the remaining widgets. */
priv->library_view = ld_category_tree_view_new (NULL);
priv->view = LD_DIAGRAM_VIEW (ld_diagram_view_new ());
priv->scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (priv->scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (priv->scrolled_window),
GTK_WIDGET (priv->view));
priv->statusbar = gtk_statusbar_new ();
priv->statusbar_menu_context_id = gtk_statusbar_get_context_id
(GTK_STATUSBAR (priv->statusbar), "menu");
priv->statusbar_symbol_context_id = gtk_statusbar_get_context_id
(GTK_STATUSBAR (priv->statusbar), "symbol");
priv->statusbar_hint_context_id = gtk_statusbar_get_context_id
(GTK_STATUSBAR (priv->statusbar), "hint");
priv->lv_viewport = gtk_viewport_new (NULL, NULL);
gtk_viewport_set_shadow_type
(GTK_VIEWPORT (priv->lv_viewport), GTK_SHADOW_NONE);
gtk_container_add (GTK_CONTAINER (priv->lv_viewport), priv->library_view);
priv->lv_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (priv->lv_window),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (priv->lv_window), priv->lv_viewport);
priv->paned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
gtk_paned_pack1 (GTK_PANED (priv->paned),
priv->lv_window, FALSE, FALSE);
gtk_paned_pack2 (GTK_PANED (priv->paned),
priv->scrolled_window, TRUE, TRUE);
gtk_paned_set_position (GTK_PANED (priv->paned), 180);
/* Pack all widgets into the window. */
priv->vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start (GTK_BOX (priv->vbox), priv->menu, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (priv->vbox), priv->toolbar, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (priv->vbox), priv->paned, TRUE, TRUE, 0);
gtk_box_pack_end (GTK_BOX (priv->vbox), priv->statusbar, FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER (self), priv->vbox);
/* Configure the window. */
g_signal_connect (self, "delete-event", G_CALLBACK (on_delete), NULL);
gtk_window_add_accel_group (GTK_WINDOW (self),
gtk_ui_manager_get_accel_group (priv->ui_manager));
gtk_window_set_default_size (GTK_WINDOW (self), 640, 440);
gtk_window_set_position (GTK_WINDOW (self), GTK_WIN_POS_CENTER);
/* Initialize the backend. */
priv->diagram = ld_diagram_new ();
g_signal_connect_after (priv->diagram, "changed",
G_CALLBACK (on_diagram_changed), self);
g_signal_connect (priv->diagram, "notify::can-undo",
G_CALLBACK (on_diagram_history_changed), self);
g_signal_connect (priv->diagram, "notify::can-redo",
G_CALLBACK (on_diagram_history_changed), self);
g_signal_connect_after (priv->diagram, "selection-changed",
G_CALLBACK (on_diagram_selection_changed), self);
priv->library = ld_library_new ();
load_library_directories (priv->library);
ld_diagram_view_set_diagram (priv->view, priv->diagram);
ld_diagram_view_set_library (priv->view, priv->library);
ld_category_view_set_category (LD_CATEGORY_VIEW (priv->library_view),
ld_library_get_root (priv->library));
g_signal_connect_after (priv->library_view, "symbol-selected",
G_CALLBACK (on_symbol_selected), self);
g_signal_connect_after (priv->library_view, "symbol-deselected",
G_CALLBACK (on_symbol_deselected), self);
diagram_set_filename (self, NULL);
priv->statusbar_hint_drag = gtk_statusbar_push
(GTK_STATUSBAR (priv->statusbar), priv->statusbar_hint_context_id,
_("Drag symbols from the library pane to add them to the diagram."));
priv->zoom_label = gtk_label_new ("");
gtk_label_set_single_line_mode (GTK_LABEL (priv->zoom_label), TRUE);
gtk_box_pack_end (GTK_BOX (gtk_statusbar_get_message_area
(GTK_STATUSBAR (priv->statusbar))), priv->zoom_label, FALSE, FALSE, 0);
g_signal_connect (priv->view, "notify::zoom",
G_CALLBACK (on_view_zoom_changed), self);
g_object_notify (G_OBJECT (priv->view), "zoom");
action_set_sensitive (self, "Undo", FALSE);
action_set_sensitive (self, "Redo", FALSE);
action_set_sensitive (self, "Delete", FALSE);
action_set_sensitive (self, "NormalSize", FALSE);
gtk_widget_grab_focus (GTK_WIDGET (priv->view));
/* Realize the window. */
gtk_widget_show_all (GTK_WIDGET (self));
/* Set up GSettings. */
priv->settings = g_settings_new ("org." PROJECT_NAME);
g_settings_bind (priv->settings, "show-main-toolbar",
gtk_action_group_get_action (priv->action_group,
"MainToolbar"), "active", G_SETTINGS_BIND_DEFAULT);
g_settings_bind (priv->settings, "show-library-pane",
gtk_action_group_get_action (priv->action_group,
"LibraryPane"), "active", G_SETTINGS_BIND_DEFAULT);
g_settings_bind (priv->settings, "show-grid",
gtk_action_group_get_action (priv->action_group,
"ShowGrid"), "active", G_SETTINGS_BIND_DEFAULT);
}
static void
ld_window_main_finalize (GObject *gobject)
{
LdWindowMain *self;
self = LD_WINDOW_MAIN (gobject);
/* Dispose of objects. Note that GtkObject has floating ref. by default
* and gtk_object_destroy () should be used for it.
*/
g_object_unref (self->priv->library);
g_object_unref (self->priv->diagram);
g_object_unref (self->priv->ui_manager);
g_object_unref (self->priv->action_group);
g_object_unref (self->priv->settings);
if (self->priv->filename)
g_free (self->priv->filename);
/* Chain up to the parent class. */
G_OBJECT_CLASS (ld_window_main_parent_class)->finalize (gobject);
}
static void
load_library_directories (LdLibrary *library)
{
GFile *file_program, *file_user;
const gchar *program_dir;
gchar *user_dir;
program_dir = PROJECT_SHARE_DIR "library";
user_dir = g_build_filename (g_get_user_data_dir (),
PROJECT_NAME, "library", NULL);
file_program = g_file_new_for_path (program_dir);
file_user = g_file_new_for_path (user_dir);
ld_library_load (library, program_dir);
/* Don't try to load the same directory twice. */
if (!g_file_equal (file_program, file_user))
ld_library_load (library, user_dir);
g_object_unref (file_user);
g_object_unref (file_program);
g_free (user_dir);
}
static void
display_and_free_error (LdWindowMain *self, const gchar *title, GError *error)
{
GtkWidget *message_dialog;
message_dialog = gtk_message_dialog_new (GTK_WINDOW (self),
GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "%s", title);
gtk_message_dialog_format_secondary_text
(GTK_MESSAGE_DIALOG (message_dialog), "%s", error->message);
g_error_free (error);
gtk_dialog_run (GTK_DIALOG (message_dialog));
gtk_widget_destroy (message_dialog);
}
/*
* on_delete:
*
* Handle requests to close the window.
*/
static gboolean
on_delete (LdWindowMain *self, GdkEvent *event, gpointer user_data)
{
return !may_quit (self);
}
/*
* update_title:
*
* Update the title of the window.
*/
static void
update_title (LdWindowMain *self)
{
gchar *title;
gchar *name;
g_return_if_fail (LD_IS_WINDOW_MAIN (self));
name = diagram_get_name (self);
title = g_strdup_printf ("%s%s - %s",
ld_diagram_get_modified (self->priv->diagram) ? "*" : "",
name, PROJECT_NAME);
gtk_window_set_title (GTK_WINDOW (self), title);
g_free (title);
g_free (name);
}
/*
* action_set_sensitive:
* @sensitive: the sensitivity state.
*
* Set sensitivity of an action.
*/
static void
action_set_sensitive (LdWindowMain *self, const gchar *name, gboolean sensitive)
{
GtkAction *action;
g_return_if_fail (LD_IS_WINDOW_MAIN (self));
g_return_if_fail (name != NULL);
action = gtk_action_group_get_action (self->priv->action_group, name);
g_return_if_fail (action != NULL);
gtk_action_set_sensitive (action, sensitive);
}
/* ===== Menu items processing ============================================= */
static void
on_ui_proxy_connected (GtkUIManager *ui, GtkAction *action,
GtkWidget *proxy, LdWindowMain *window)
{
if (GTK_IS_MENU_ITEM (proxy))
{
g_signal_connect (proxy, "select",
G_CALLBACK (on_menu_item_selected), window);
g_signal_connect (proxy, "deselect",
G_CALLBACK (on_menu_item_deselected), window);
}
}
static void
on_ui_proxy_disconnected (GtkUIManager *ui, GtkAction *action,
GtkWidget *proxy, LdWindowMain *window)
{
if (GTK_IS_MENU_ITEM (proxy))
{
g_signal_handlers_disconnect_by_func
(proxy, G_CALLBACK (on_menu_item_selected), window);
g_signal_handlers_disconnect_by_func
(proxy, G_CALLBACK (on_menu_item_deselected), window);
}
}
static void
on_menu_item_selected (GtkWidget *item, LdWindowMain *window)
{
GtkAction *action;
gchar *tooltip;
action = gtk_activatable_get_related_action (GTK_ACTIVATABLE (item));
g_object_get (G_OBJECT (action), "tooltip", &tooltip, NULL);
if (tooltip != NULL)
gtk_statusbar_push (GTK_STATUSBAR (window->priv->statusbar),
window->priv->statusbar_menu_context_id, tooltip);
g_free (tooltip);
}
static void
on_menu_item_deselected (GtkMenuItem *item, LdWindowMain *window)
{
gtk_statusbar_pop (GTK_STATUSBAR (window->priv->statusbar),
window->priv->statusbar_menu_context_id);
}
/* ===== Diagram handling ================================================== */
static void
on_diagram_changed (LdDiagram *diagram, LdWindowMain *self)
{
update_title (self);
if (self->priv->statusbar_hint_drag)
{
gtk_statusbar_remove (GTK_STATUSBAR (self->priv->statusbar),
self->priv->statusbar_hint_context_id,
self->priv->statusbar_hint_drag);
self->priv->statusbar_hint_drag = 0;
}
}
static void
on_diagram_history_changed (LdDiagram *diagram,
GParamSpec *pspec, LdWindowMain *self)
{
action_set_sensitive (self, "Undo", ld_diagram_can_undo (diagram));
action_set_sensitive (self, "Redo", ld_diagram_can_redo (diagram));
}
static void
on_diagram_selection_changed (LdDiagram *diagram, LdWindowMain *self)
{
gboolean selection_empty;
selection_empty = !ld_diagram_get_selection (diagram);
action_set_sensitive (self, "Delete", !selection_empty);
}
/*
* diagram_get_name:
*
* Get the name of the currently opened diagram.
*/
static gchar *
diagram_get_name (LdWindowMain *self)
{
g_return_val_if_fail (LD_IS_WINDOW_MAIN (self), NULL);
if (self->priv->filename)
return g_filename_display_basename (self->priv->filename);
return g_strdup (_("Unsaved Diagram"));
}
/*
* diagram_set_filename:
* @filename: (allow-none): the new filename. %NULL for a new file.
*
* Set the filename corresponding to the currently opened diagram.
* The function takes ownership of the string.
*/
static void
diagram_set_filename (LdWindowMain *self, gchar *filename)
{
g_return_if_fail (LD_IS_WINDOW_MAIN (self));
if (self->priv->filename)
g_free (self->priv->filename);
self->priv->filename = filename;
update_title (self);
}
/*
* diagram_new:
*
* Create a new diagram.
*/
static void
diagram_new (LdWindowMain *self)
{
g_return_if_fail (LD_IS_WINDOW_MAIN (self));
if (!may_close_diagram (self, _("Save the changes to diagram \"%s\" before"
" closing it and creating a new one?")))
return;
ld_diagram_clear (self->priv->diagram);
ld_diagram_set_modified (self->priv->diagram, FALSE);
ld_diagram_view_set_x (self->priv->view, 0);
ld_diagram_view_set_y (self->priv->view, 0);
ld_diagram_view_set_zoom (self->priv->view, 1);
diagram_set_filename (self, NULL);
}
/*
* diagram_save:
*
* Save the current diagram.
*/
static gboolean
diagram_save (LdWindowMain *self, GtkWindow *dialog_parent,
const gchar *filename)
{
GError *error;
g_return_val_if_fail (LD_IS_WINDOW_MAIN (self), FALSE);
g_return_val_if_fail (filename != NULL, FALSE);
error = NULL;
ld_diagram_save_to_file (self->priv->diagram, filename, &error);
if (error)
{
GtkWidget *message_dialog;
g_warning ("saving failed: %s", error->message);
g_error_free (error);
message_dialog = gtk_message_dialog_new (dialog_parent,
GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
_("Failed to save the diagram"));
gtk_message_dialog_format_secondary_text
(GTK_MESSAGE_DIALOG (message_dialog),
_("Try again or save it under another name."));
gtk_dialog_run (GTK_DIALOG (message_dialog));
gtk_widget_destroy (message_dialog);
return FALSE;
}
ld_diagram_set_modified (self->priv->diagram, FALSE);
update_title (self);
return TRUE;
}
/*
* diagram_open:
*
* Open a diagram from a file.
*/
static gboolean
diagram_open (LdWindowMain *self, const gchar *filename)
{
GError *error;
error = NULL;
ld_diagram_load_from_file (self->priv->diagram, filename, &error);
if (error)
{
GtkWidget *message_dialog;
g_warning ("loading failed: %s", error->message);
message_dialog = gtk_message_dialog_new (GTK_WINDOW (self),
GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
_("Failed to open the file"));
if (error->domain != G_FILE_ERROR)
{
gchar *display_filename;
display_filename = g_filename_display_name (filename);
gtk_message_dialog_format_secondary_text
(GTK_MESSAGE_DIALOG (message_dialog),
_("Failed to open file `%s': Invalid contents."), filename);
g_free (display_filename);
}
else
gtk_message_dialog_format_secondary_text
(GTK_MESSAGE_DIALOG (message_dialog),
"%s", error->message);
gtk_dialog_run (GTK_DIALOG (message_dialog));
gtk_widget_destroy (message_dialog);
g_error_free (error);
return FALSE;
}
ld_diagram_set_modified (self->priv->diagram, FALSE);
diagram_set_filename (self, g_strdup (filename));
return TRUE;
}
/*
* diagram_get_file_filter:
*
* Return value: a new #GtkFileFilter object for diagrams.
*/
static GtkFileFilter *
diagram_get_file_filter (void)
{
GtkFileFilter *filter;
filter = gtk_file_filter_new ();
gtk_file_filter_set_name (filter, _("Logdiag Diagrams (*.ldd)"));
gtk_file_filter_add_pattern (filter, "*.ldd");
return filter;
}
/*
* diagram_show_open_dialog:
*
* Show a dialog for opening a diagram.
*/
static void
diagram_show_open_dialog (LdWindowMain *self)
{
GtkWidget *dialog;
g_return_if_fail (LD_IS_WINDOW_MAIN (self));
if (!may_close_diagram (self, _("Save the changes to diagram \"%s\" before"
" closing it and opening another one?")))
return;
dialog = gtk_file_chooser_dialog_new (_("Open..."), GTK_WINDOW (self),
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog),
diagram_get_file_filter ());
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
{
gchar *filename;
filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
diagram_open (self, filename);
g_free (filename);
}
gtk_widget_destroy (dialog);
}
/*
* diagram_show_save_as_dialog:
*
* Show a dialog for saving the diagram.
*/
static void
diagram_show_save_as_dialog (LdWindowMain *self)
{
GtkWidget *dialog;
GtkFileChooser *file_chooser;
gchar *filename;
g_return_if_fail (LD_IS_WINDOW_MAIN (self));
dialog = gtk_file_chooser_dialog_new (_("Save As..."), GTK_WINDOW (self),
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
NULL);
g_object_set (dialog, "do-overwrite-confirmation", TRUE, NULL);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog),
diagram_get_file_filter ());
file_chooser = GTK_FILE_CHOOSER (dialog);
if (self->priv->filename)
gtk_file_chooser_set_filename (file_chooser, self->priv->filename);
else
{
filename = g_strdup_printf ("%s.ldd", _("Untitled diagram"));
gtk_file_chooser_set_current_name (file_chooser, filename);
g_free (filename);
}
while (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
{
filename = gtk_file_chooser_get_filename (file_chooser);
if (diagram_save (self, GTK_WINDOW (dialog), filename))
{
diagram_set_filename (self, filename);
break;
}
g_free (filename);
}
gtk_widget_destroy (dialog);
}
/*
* may_close_diagram:
* @dialog_message: the dialog message to display to the user if the diagram
* has been modified.
*
* When no changes have been made to the current diagram, the function
* lets the caller proceed. Otherwise the user is asked for further actions.
* If he chooses to save the diagram, the function will handle this action.
*
* Return value: %FALSE if the current action should be cancelled.
* %TRUE if the caller may proceed.
*/
static gboolean
may_close_diagram (LdWindowMain *self, const gchar *dialog_message)
{
GtkWidget *message_dialog;
gchar *name;
gint result;
g_return_val_if_fail (LD_IS_WINDOW_MAIN (self), TRUE);
g_return_val_if_fail (dialog_message != NULL, TRUE);
if (!ld_diagram_get_modified (self->priv->diagram))
return TRUE;
name = diagram_get_name (self);
/* TODO: Show the time since the diagram was last saved.
* (Record the event with g_get_current_time().)
*/
message_dialog = gtk_message_dialog_new (GTK_WINDOW (self),
GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING, GTK_BUTTONS_NONE,
dialog_message, name);
gtk_message_dialog_format_secondary_text
(GTK_MESSAGE_DIALOG (message_dialog),
_("If you don't save, changes will be permanently lost."));
gtk_dialog_add_buttons (GTK_DIALOG (message_dialog),
_("Close _without Saving"), GTK_RESPONSE_NO,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_YES,
NULL);
result = gtk_dialog_run (GTK_DIALOG (message_dialog));
gtk_widget_destroy (message_dialog);
g_free (name);
switch (result)
{
case GTK_RESPONSE_NO:
return TRUE;
case GTK_RESPONSE_YES:
on_action_save (NULL, self);
return TRUE;
case GTK_RESPONSE_CANCEL:
case GTK_RESPONSE_DELETE_EVENT:
return FALSE;
default:
g_assert_not_reached ();
}
}
/*
* may_quit:
*
* A variant on may_close_diagram() for the occasion of closing
* the whole application.
*
* Return value: %TRUE if the application may quit, %FALSE otherwise.
*/
static gboolean
may_quit (LdWindowMain *self)
{
g_return_val_if_fail (LD_IS_WINDOW_MAIN (self), TRUE);
return may_close_diagram (self,
_("Save the changes to diagram \"%s\" before closing?"));
}
/* ===== User interface actions ============================================ */
static void
on_symbol_selected (LdCategoryView *view,
LdSymbol *symbol, const gchar *path, LdWindowMain *self)
{
const gchar *symbol_name;
symbol_name = ld_symbol_get_human_name (symbol);
gtk_statusbar_push (GTK_STATUSBAR (self->priv->statusbar),
self->priv->statusbar_menu_context_id, symbol_name);
}
static void
on_symbol_deselected (LdCategoryView *view,
LdSymbol *symbol, const gchar *path, LdWindowMain *self)
{
gtk_statusbar_pop (GTK_STATUSBAR (self->priv->statusbar),
self->priv->statusbar_menu_context_id);
}
static void
on_view_zoom_changed (LdDiagramView *view, GParamSpec *pspec,
LdWindowMain *self)
{
gchar *zoom;
action_set_sensitive (self, "ZoomIn",
ld_diagram_view_can_zoom_in (self->priv->view));
action_set_sensitive (self, "ZoomOut",
ld_diagram_view_can_zoom_out (self->priv->view));
action_set_sensitive (self, "NormalSize",
ld_diagram_view_get_zoom (self->priv->view) != 1);
zoom = g_strdup_printf (_("%d%%"),
(gint) (ld_diagram_view_get_zoom (self->priv->view) * 100 + 0.5));
gtk_label_set_text (GTK_LABEL (self->priv->zoom_label), zoom);
g_free (zoom);
}
static void
on_action_new (GtkAction *action, LdWindowMain *self)
{
diagram_new (self);
}
static void
on_action_open (GtkAction *action, LdWindowMain *self)
{
diagram_show_open_dialog (self);
}
static void
on_action_save (GtkAction *action, LdWindowMain *self)
{
if (!self->priv->filename
|| !diagram_save (self, GTK_WINDOW (self), self->priv->filename))
diagram_show_save_as_dialog (self);
}
static void
on_action_save_as (GtkAction *action, LdWindowMain *self)
{
diagram_show_save_as_dialog (self);
}
static void
on_action_print (GtkAction *action, LdWindowMain *self)
{
static GtkPrintSettings *settings = NULL;
GError *error = NULL;
GtkPrintOperation *print;
GtkPrintOperationResult res;
gchar *name;
print = gtk_print_operation_new ();
gtk_print_operation_set_n_pages (print, 1);
gtk_print_operation_set_embed_page_setup (print, TRUE);
gtk_print_operation_set_unit (print, GTK_UNIT_MM);
name = diagram_get_name (self);
gtk_print_operation_set_job_name (print, name);
g_free (name);
if (settings != NULL)
gtk_print_operation_set_print_settings (print, settings);
g_signal_connect (print, "draw-page",
G_CALLBACK (on_action_print_draw_page), self);
/* On Windows, it is not possible to get a print preview from the system
* print dialog. But in Windows XP previews do not work at all--unreadable
* EMFs come out. Windows 10 errors out with "A sharing violation occurred
* while accessing" the temporary EMF file on our first run of
* GtkPrintOperation, and following that it opens the previews up in
* fucking Paint, so there is no point in trying. It lacks a stage
* or controls for setting up page parameters anyway.
*/
res = gtk_print_operation_run (print,
GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG,
GTK_WINDOW (self), &error);
if (res == GTK_PRINT_OPERATION_RESULT_APPLY)
{
if (settings != NULL)
g_object_unref (settings);
settings
= g_object_ref (gtk_print_operation_get_print_settings (print));
}
if (error)
display_and_free_error (self, _("Error"), error);
g_object_unref (print);
}
static void
on_action_print_draw_page (GtkPrintOperation *operation,
GtkPrintContext *context, int page_nr, LdWindowMain *self)
{
cairo_t *cr;
LdDiagramView *view;
gdouble area_width_mm, area_height_mm;
gdouble diagram_width_mm, diagram_height_mm;
gdouble diagram_to_export_units, scale, width_fit, height_fit;
LdRectangle bounds;
cr = gtk_print_context_get_cairo_context (context);
view = self->priv->view;
area_width_mm = gtk_print_context_get_width (context);
area_height_mm = gtk_print_context_get_height (context);
diagram_to_export_units = ld_diagram_view_get_export_bounds (view, &bounds);
/* Scale for the view's constant, measured in milimetres. */
scale = 1 / diagram_to_export_units * LD_DIAGRAM_VIEW_BASE_UNIT_LENGTH;
diagram_width_mm = bounds.width * scale;
diagram_height_mm = bounds.height * scale;
/* Scale to fit the paper, taking care to not divide by zero. */
width_fit = (area_width_mm < diagram_width_mm)
? area_width_mm / diagram_width_mm : 1;
height_fit = (area_height_mm < diagram_height_mm)
? area_height_mm / diagram_height_mm : 1;
scale *= MIN (width_fit, height_fit);
cairo_scale (cr, scale, scale);
cairo_translate (cr, -bounds.x, -bounds.y);
ld_diagram_view_export (view, cr, &bounds);
}
static void
on_action_quit (GtkAction *action, LdWindowMain *self)
{
if (may_quit (self))
gtk_widget_destroy (GTK_WIDGET (self));
}
static GFile *
user_guide_path (const gchar *language)
{
gchar *filename, *path;
GFile *file;
filename = g_strdup_printf ("user-guide-%s.html", language);
path = g_build_filename (PROJECT_DOC_DIR, "user-guide", filename, NULL);
g_free (filename);
file = g_file_new_for_path (path);
g_free (path);
return file;
}
static gboolean
open_file (GFile *file, GdkScreen *screen, GError **error)
{
GdkDisplay *display;
GAppInfo *app_info;
GdkAppLaunchContext *context;
GList link;
gboolean success;
/* GLib 2.36.1 prevents us from using gtk_show_uri() on Windows XP. */
if (!(app_info = g_file_query_default_handler (file, NULL, error)))
return FALSE;
link.next = link.prev = NULL;
link.data = file;
display = gdk_screen_get_display (screen);
context = gdk_display_get_app_launch_context (display);
gdk_app_launch_context_set_screen (context, screen);
success = g_app_info_launch (app_info,
&link, G_APP_LAUNCH_CONTEXT (context), error);
g_object_unref (context);
return success;
}
static void
on_action_user_guide (GtkAction *action, LdWindowMain *self)
{
const gchar *const *iter;
GFile *file;
GError *error = NULL;
/* Look for a usable language variant, or fall back to the lingua franca. */
for (iter = g_get_language_names (); *iter; iter++)
{
if (g_file_query_exists ((file = user_guide_path (*iter)), NULL))
break;
g_object_unref (file);
}
if (!*iter)
file = user_guide_path ("en");
if (!open_file (file, gtk_window_get_screen (GTK_WINDOW (self)), &error))
{
display_and_free_error (self,
_("Failed to open the user guide"), error);
}
g_object_unref (file);
}
static void
on_action_about (GtkAction *action, LdWindowMain *self)
{
GtkWidget *about_dialog;
GBytes *license;
license = g_resources_lookup_data ("/logdiag/LICENSE",
G_RESOURCE_LOOKUP_FLAGS_NONE, NULL);
about_dialog = g_object_new (GTK_TYPE_ABOUT_DIALOG,
"program-name", PROJECT_NAME,
"logo-icon-name", PROJECT_NAME,
"version", PROJECT_VERSION,
"translator-credits", _("translator-credits"),
"copyright", "Copyright 2010 - 2021 Přemysl Eric Janouch",
"license", g_bytes_get_data (license, NULL),
"website", PROJECT_URL,
NULL);
g_bytes_unref (license);
g_signal_connect (about_dialog, "activate-link",
G_CALLBACK (on_action_about_activate_link), self);
gtk_window_set_transient_for (GTK_WINDOW (about_dialog), GTK_WINDOW (self));
gtk_window_set_modal (GTK_WINDOW (about_dialog), TRUE);
gtk_window_set_destroy_with_parent (GTK_WINDOW (about_dialog), TRUE);
gtk_dialog_run (GTK_DIALOG (about_dialog));
gtk_widget_destroy (about_dialog);
}
static gboolean
on_action_about_activate_link (GtkAboutDialog *dialog, gchar *uri,
LdWindowMain *self)
{
#ifdef G_OS_WIN32
GdkWindow *window;
window = gtk_widget_get_window (GTK_WIDGET (self));
/* gtk_show_uri() on Windows XP fails, due to trying to establish
* an SSL connection, so let's first try to not do that on Windows.
* `cmd.exe /c start "" ...` would pop up a command line window,
* so use SHELL32.DLL directly. rundll does not cover this.
* There doesn't seem to be anything better directly in GIO/GLib.
*
* When we fail here, we fall back to normal processing.
*/
if ((INT_PTR) ShellExecute (gdk_win32_window_get_handle (window),
"open", uri, NULL, NULL, SW_SHOWNORMAL) > 32)
return TRUE;
#endif /* G_OS_WIN32 */
return FALSE;
}
static void
on_action_undo (GtkAction *action, LdWindowMain *self)
{
ld_diagram_undo (self->priv->diagram);
}
static void
on_action_redo (GtkAction *action, LdWindowMain *self)
{
ld_diagram_redo (self->priv->diagram);
}
static void
on_action_delete (GtkAction *action, LdWindowMain *self)
{
ld_diagram_remove_selection (self->priv->diagram);
}
static void
on_action_select_all (GtkAction *action, LdWindowMain *self)
{
ld_diagram_select_all (self->priv->diagram);
}
static void
on_action_main_toolbar (GtkToggleAction *action, LdWindowMain *self)
{
gtk_widget_set_visible (self->priv->toolbar,
gtk_toggle_action_get_active (action));
}
static void
on_action_library_pane (GtkToggleAction *action, LdWindowMain *self)
{
gtk_widget_set_visible (self->priv->lv_window,
gtk_toggle_action_get_active (action));
}
static void
on_action_grid (GtkToggleAction *action, LdWindowMain *self)
{
ld_diagram_view_set_show_grid (self->priv->view,
gtk_toggle_action_get_active (action));
}
static void
on_action_zoom_in (GtkAction *action, LdWindowMain *self)
{
ld_diagram_view_zoom_in (self->priv->view);
}
static void
on_action_zoom_out (GtkAction *action, LdWindowMain *self)
{
ld_diagram_view_zoom_out (self->priv->view);
}
static void
on_action_normal_size (GtkAction *action, LdWindowMain *self)
{
ld_diagram_view_set_zoom (self->priv->view, 1);
}