X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fui%2Fgui%2Fmain.c;h=4ed38b3f357fb165c112f78d5da3f651fc588796;hb=e6b6e7d67f173867d731ebca6b8fbad5a2f82560;hp=9bd278d3397965ef1c0b5d8b52d141decc930bdf;hpb=a8c96cbb1f8cf84047595f15b47dd407e292325e;p=pspp

diff --git a/src/ui/gui/main.c b/src/ui/gui/main.c
index 9bd278d339..4ed38b3f35 100644
--- a/src/ui/gui/main.c
+++ b/src/ui/gui/main.c
@@ -1,5 +1,6 @@
 /* PSPPIRE - a graphical user interface for PSPP.
-   Copyright (C) 2004, 2005, 2006, 2010, 2011, 2012, 2013, 2014, 2015  Free Software Foundation
+   Copyright (C) 2004, 2005, 2006, 2010, 2011, 2012, 2013, 2014, 2015,
+   2016, 2020  Free Software Foundation
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -16,6 +17,8 @@
 
 #include <config.h>
 
+#include "pre-initialisation.h"
+
 #include "ui/gui/psppire.h"
 
 #include <gtk/gtk.h>
@@ -27,10 +30,14 @@
 #include "libpspp/assertion.h"
 #include "libpspp/cast.h"
 #include "libpspp/copyleft.h"
+#include "libpspp/message.h"
 #include "libpspp/str.h"
 #include "libpspp/string-array.h"
 #include "libpspp/version.h"
 #include "ui/source-init-opts.h"
+#include "ui/gui/psppire-syntax-window.h"
+#include "ui/gui/psppire-data-window.h"
+#include "ui/gui/psppire-output-window.h"
 
 #include "gl/configmake.h"
 #include "gl/progname.h"
@@ -43,188 +50,40 @@
 #define N_(msgid) msgid
 
 
-GdkWindow *create_splash_window (GMainContext *context);
-gboolean destroy_splash_window (gpointer ud);
-
-
-
-
-/* Arguments to be interpreted before the X server gets initialised */
-
-enum
-  {
-    OPT_HELP,
-    OPT_VERSION,
-    OPT_NO_SPLASH,
-    OPT_MEASURE_STARTUP,
-    N_STARTUP_OPTIONS
-  };
-
-static const struct argv_option startup_options[N_STARTUP_OPTIONS] =
-  {
-    {"help",      'h', no_argument, OPT_HELP},
-    {"version",   'V', no_argument, OPT_VERSION},
-    {"no-splash", 'q', no_argument, OPT_NO_SPLASH},
-    {"measure-startup", 0, no_argument, OPT_MEASURE_STARTUP},
-  };
-
-/* --measure-startup: Prints the elapsed time to start up and load any file
-   specified on the command line. */
-static gboolean measure_startup;
-static GTimer *startup;
-
-static void
-usage (void)
-{
-  char *inc_path = string_array_join (include_path_default (), " ");
-  GOptionGroup *gtk_options;
-  GOptionContext *ctx;
-  gchar *gtk_help_base, *gtk_help;
-
-  /* Get help text for GTK+ options.  */
-  ctx = g_option_context_new ("psppire");
-  gtk_options = gtk_get_option_group (FALSE);
-  gtk_help_base = g_option_context_get_help (ctx, FALSE, gtk_options);
-  g_option_context_free (ctx);
-
-  /* The GTK+ help text starts with usage instructions that we don't want,
-     followed by a blank line.  Trim off everything up to and including the
-     first blank line. */
-  gtk_help = strstr (gtk_help_base, "\n\n");
-  gtk_help = gtk_help != NULL ? gtk_help + 2 : gtk_help_base;
-
-  printf (_("\
-PSPPIRE, a GUI for PSPP, a program for statistical analysis of sampled data.\n\
-Usage: %s [OPTION]... FILE\n\
-\n\
-Arguments to long options also apply to equivalent short options.\n\
-\n\
-GUI options:\n\
-  -q, --no-splash           don't show splash screen during startup\n\
-\n\
-%s\
-Language options:\n\
-  -I, --include=DIR         append DIR to search path\n\
-  -I-, --no-include         clear search path\n\
-  -a, --algorithm={compatible|enhanced}\n\
-                            set to `compatible' if you want output\n\
-                            calculated from broken algorithms\n\
-  -x, --syntax={compatible|enhanced}\n\
-                            set to `compatible' to disable PSPP extensions\n\
-  -i, --interactive         interpret syntax in interactive mode\n\
-  -s, --safer               don't allow some unsafe operations\n\
-Default search path: %s\n\
-\n\
-Informative output:\n\
-  -h, --help                display this help and exit\n\
-  -V, --version             output version information and exit\n\
-\n\
-A non-option argument is interpreted as a data file in .sav or .zsav or .por\n\
-format or a syntax file to load.\n"),
-          program_name, gtk_help, inc_path);
-
-  free (inc_path);
-  g_free (gtk_help_base);
-
-  emit_bug_reporting_address ();
-  exit (EXIT_SUCCESS);
-}
-
-static void
-startup_option_callback (int id, void *show_splash_)
-{
-  gboolean *show_splash = show_splash_;
-
-  switch (id)
-    {
-    case OPT_HELP:
-      usage ();
-      break;
-
-    case OPT_VERSION:
-      version_etc (stdout, "psppire", PACKAGE_NAME, PACKAGE_VERSION,
-                   "Ben Pfaff", "John Darrington", "Jason Stover",
-                   NULL_SENTINEL);
-      exit (EXIT_SUCCESS);
-
-    case OPT_NO_SPLASH:
-      *show_splash = FALSE;
-      break;
-
-    case OPT_MEASURE_STARTUP:
-      measure_startup = TRUE;
-      break;
-
-    default:
-      NOT_REACHED ();
-    }
-}
 
-static gboolean UNUSED
-print_startup_time (gpointer data)
+static gboolean
+show_version_and_exit (void)
 {
-  g_timer_stop (startup);
-  printf ("%.3f seconds elapsed\n", g_timer_elapsed (startup, NULL));
-  g_timer_destroy (startup);
-  startup = NULL;
+  version_etc (stdout, "psppire", PACKAGE_NAME, PACKAGE_VERSION,
+               "Ben Pfaff", "John Darrington", "Jason Stover", NULL_SENTINEL);
 
-  return FALSE;
-}
+  exit (0);
 
-#ifdef __APPLE__
-static const bool apple = true;
-#else
-static const bool apple = false;
-#endif
-
-/* Searches ARGV for the -psn_xxxx option that the desktop application
-   launcher passes in, and removes it if it finds it.  Returns the new value
-   of ARGC. */
-static inline int
-remove_psn (int argc, char **argv)
-{
-  if (apple)
-    {
-      int i;
-
-      for (i = 0; i < argc; i++)
-	{
-	  if (!strncmp (argv[i], "-psn", 4))
-	    {
-	      remove_element (argv, argc + 1, sizeof *argv, i);
-	      return argc - 1;
-	    }
-	}
-    }
-  return argc;
+  return TRUE;
 }
 
 
-gboolean
-init_prepare (GSource *source, gint *timeout_)
+
+static gboolean
+init_prepare (GSource * source, gint * timeout_)
 {
   return TRUE;
 }
 
-
-
-gboolean
-init_check (GSource *source)
+static gboolean
+init_check (GSource * source)
 {
   return TRUE;
 }
 
-
-gboolean
-init_dispatch (GSource *ss,
-	       GSourceFunc callback,
-	       gpointer user_data)
+static gboolean
+init_dispatch (GSource * ss, GSourceFunc callback, gpointer user_data)
 {
-  struct init_source *is = (struct init_source *)ss;
+  struct init_source *is = (struct init_source *) ss;
 
   bool finished = initialize (is);
   is->state++;
-  
+
   if (finished)
     {
       g_main_loop_quit (is->loop);
@@ -234,221 +93,347 @@ init_dispatch (GSource *ss,
   return TRUE;
 }
 
-static GSourceFuncs init_funcs = {init_prepare, init_check, init_dispatch, NULL};
+static GSourceFuncs init_funcs =
+  { init_prepare, init_check, init_dispatch, NULL, NULL, NULL };
 
-
+static GtkWidget *wsplash = 0;
+static gint64 start_time = 0;
 
-int
-main (int argc, char *argv[])
-{
-  gboolean show_splash = TRUE;
-  struct argv_parser *parser;
-  const gchar *vers;
 
-  set_program_name (argv[0]);
+static GtkWidget *
+create_splash_window (void)
+{
+  GtkWidget *sp = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 
-#if !GLIB_CHECK_VERSION(2,32,0)
-  /* g_thread_init() was required before glib 2.32, but it is deprecated since
-     then and calling it yields a compile-time warning. */
-  g_thread_init (NULL);
-#endif
+  const gchar *filename = PKGDATADIR "/splash.png";
+  const char *relocated_filename = relocate (filename);
+  GtkWidget *l = gtk_image_new_from_file (relocated_filename);
+  if (filename != relocated_filename)
+    free (CONST_CAST (char *, relocated_filename));
 
-  gtk_disable_setlocale ();
+  gtk_container_add (GTK_CONTAINER (sp), l);
+  gtk_window_set_type_hint (GTK_WINDOW (sp),
+                            GDK_WINDOW_TYPE_HINT_SPLASHSCREEN);
+  gtk_window_set_position (GTK_WINDOW (sp), GTK_WIN_POS_CENTER);
+  gtk_window_set_skip_pager_hint (GTK_WINDOW (sp), TRUE);
+  gtk_window_set_skip_taskbar_hint (GTK_WINDOW (sp), TRUE);
+  gtk_window_set_focus_on_map (GTK_WINDOW (sp), FALSE);
+  gtk_window_set_accept_focus (GTK_WINDOW (sp), FALSE);
+
+  GdkGeometry hints;
+  hints.max_height = 100;
+  hints.max_width = 200;
+  gtk_window_set_geometry_hints (GTK_WINDOW (sp),
+                                 NULL, &hints, GDK_HINT_MAX_SIZE);
+
+
+  gtk_window_set_gravity (GTK_WINDOW (sp), GDK_GRAVITY_CENTER);
+
+  gtk_window_set_modal (GTK_WINDOW (sp), TRUE);
+  gtk_window_set_decorated (GTK_WINDOW (sp), FALSE);
+  gtk_window_set_keep_above (GTK_WINDOW (sp), TRUE);
+  gtk_widget_show_all (sp);
+  return sp;
+}
 
-  startup = g_timer_new ();
-  g_timer_start (startup);
 
-  if ( (vers = gtk_check_version (GTK_MAJOR_VERSION,
-				 GTK_MINOR_VERSION,
-				 GTK_MICRO_VERSION)) )
-    {
-      g_warning ("%s", vers);
-    }
+static gint
+on_local_options (GApplication * application,
+                  GVariantDict * options, gpointer user_data)
+{
+  {
+    GVariant *b =
+      g_variant_dict_lookup_value (options, "no-unique",
+				   G_VARIANT_TYPE_BOOLEAN);
+    if (b)
+      {
+	GApplicationFlags flags =  g_application_get_flags (application);
+	flags |= G_APPLICATION_NON_UNIQUE;
+	g_application_set_flags (application, flags);
+	g_variant_unref (b);
+      }
+  }
+  {
+    GVariant *b =
+      g_variant_dict_lookup_value (options, "no-splash",
+				   G_VARIANT_TYPE_BOOLEAN);
+    if (b)
+      g_variant_unref (b);
+    else
+      start_time = g_get_monotonic_time ();
+  }
 
-  argc = remove_psn (argc, argv);
 
-  /* Parse our own options. 
-     This must come BEFORE gdk_init otherwise options such as 
-     --help --version which ought to work without an X server, won't.
-  */
-  parser = argv_parser_create ();
-  argv_parser_add_options (parser, startup_options, N_STARTUP_OPTIONS,
-                           startup_option_callback, &show_splash);
-  source_init_register_argv_parser (parser);
-  if (!argv_parser_run (parser, argc, argv))
-    exit (EXIT_FAILURE);
-  argv_parser_destroy (parser);
+  return -1;
+}
 
-  /* Initialise GDK.  GTK gets initialized later. */
-  gdk_init (&argc, &argv);
 
+static void
+on_startup (GApplication * app, gpointer ud)
+{
   GMainContext *context = g_main_context_new ();
-  
-  GdkWindow *win = show_splash ? create_splash_window (context) : NULL;
+
+  if (start_time != 0)
+    {
+      wsplash = create_splash_window ();
+      gtk_application_add_window (GTK_APPLICATION (app),
+                                  GTK_WINDOW (wsplash));
+    }
 
   GMainLoop *loop = g_main_loop_new (context, FALSE);
 
-  GSource *ss = g_source_new (&init_funcs,
-			      sizeof (struct init_source));
-  
-  ((struct init_source *) ss)->state = 0;
-  
-  g_source_set_priority (ss, G_PRIORITY_DEFAULT);
-    
-  g_source_attach (ss, context);
+  GSource *ss = g_source_new (&init_funcs, sizeof (struct init_source));
 
-  ((struct init_source *) ss)->argc = &argc;
-  ((struct init_source *) ss)->argv = &argv;
   ((struct init_source *) ss)->loop = loop;
-  ((struct init_source *) ss)->file = optind < argc ? argv[optind] : NULL;
-  
-  g_source_unref (ss);
+  ((struct init_source *) ss)->state = 0;
 
-  g_main_loop_run (loop);
+  g_source_set_priority (ss, G_PRIORITY_DEFAULT);
 
-  g_main_loop_unref (loop);
-  g_main_context_unref (context);
+  g_source_attach (ss, context);
+  g_main_loop_run (loop);
+}
 
-  if (win)
-    g_timeout_add (500, destroy_splash_window, win);
 
-  gtk_main ();
+static void
+post_initialise (GApplication * app)
+{
+  register_selection_functions ();
+  psppire_output_window_setup ();
 
-  /* Not much point in this except to check for memory leaks */
-  de_initialize ();
-  
-  return 0;
+  GSimpleAction *quit = g_simple_action_new ("quit", NULL);
+  g_signal_connect_swapped (quit, "activate", G_CALLBACK (psppire_quit), app);
+  g_action_map_add_action (G_ACTION_MAP (app), G_ACTION (quit));
 }
 
 
+#define SPLASH_DURATION 1000
 
-
-
-struct splash_source
+static gboolean
+destroy_splash (gpointer ud)
 {
-  GSource parent;
-  cairo_surface_t *sfc;
-};
+  GtkWidget *sp = GTK_WIDGET (ud);
+  gtk_widget_destroy (sp);
+  wsplash = NULL;
+  return G_SOURCE_REMOVE;
+}
+
 
-void
-fill_splash_window (GdkWindow *win, cairo_surface_t *sfce)
+static void
+wait_for_splash (GApplication *app, GtkWindow *x)
 {
-  cairo_t *cr = gdk_cairo_create (win);
-  
-  cairo_set_source_surface (cr, sfce, 0, 0);
-  
-  cairo_paint (cr);
-  cairo_destroy (cr);
+  if (wsplash)
+    {
+      gtk_window_set_transient_for (GTK_WINDOW (wsplash), x);
+      gtk_application_add_window (GTK_APPLICATION (app), GTK_WINDOW (wsplash));
+      gtk_window_set_keep_above (GTK_WINDOW (wsplash), TRUE);
+      gtk_window_present (GTK_WINDOW (wsplash));
+
+      /* Remove the splash screen after SPLASH_DURATION milliseconds */
+      gint64 elapsed_time = (g_get_monotonic_time () - start_time) / 1000;
+      if (SPLASH_DURATION - elapsed_time <= 0)
+	destroy_splash (wsplash);
+      else
+	g_timeout_add (SPLASH_DURATION - elapsed_time, destroy_splash, wsplash);
+    }
 }
 
-gboolean
-splash_prepare  (GSource    *source,
-	    gint       *timeout_)
+static GtkWidget *fatal_error_dialog = NULL;
+static GtkWidget *fatal_error_label;
+static const char *diagnostic_info;
+
+static void
+fatal_error_handler (int sig)
 {
-  GdkEvent *e = gdk_event_peek ();
-  if (!e)
-    return FALSE;
+  /* Reset SIG to its default handling so that if it happens again we won't
+     recurse. */
+  signal (sig, SIG_DFL);
 
-  gdk_event_free (e);
-  return TRUE;
-}
+  static char message [1024];
+  strcpy (message, "proximate cause:    ");
+  switch (sig)
+    {
+    case SIGABRT:
+      strcat (message, "Assertion Failure/Abort");
+      break;
+    case SIGFPE:
+      strcat (message, "Floating Point Exception");
+      break;
+    case SIGSEGV:
+      strcat (message, "Segmentation Violation");
+      break;
+    default:
+      strcat (message, "Unknown");
+      break;
+    }
+  strcat (message, "\n");
+  strcat (message, diagnostic_info);
 
-gboolean
-splash_check   (GSource    *source)
-{
-  GdkEvent *e = gdk_event_peek ();
-  if (!e)
-    return FALSE;
+  g_object_set (fatal_error_label,
+                "label", message,
+                NULL);
 
-  gdk_event_free (e);
-  return TRUE;
-}
+  gtk_dialog_run (GTK_DIALOG (fatal_error_dialog));
 
+  /* Re-raise the signal so that we terminate with the correct status. */
+  raise (sig);
+}
 
-gboolean
-splash_dispatch (GSource *ss,
-	    GSourceFunc callback,
-	    gpointer    user_data)
+static void
+on_activate (GApplication * app, gpointer ud)
 {
-  struct splash_source *source = (struct splash_source *) ss;
-  GdkEvent *e = gdk_event_get ();
-  if (!e)
-    return TRUE;
-
-  GdkWindow *w = ((GdkEventAny *)e)->window;
+  struct sigaction fatal_error_action;
+  sigset_t sigset;
+  g_return_if_fail (0 == sigemptyset (&sigset));
+  fatal_error_dialog =
+    gtk_message_dialog_new (NULL, 0, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE,
+                            _("Psppire: Fatal Error"));
+
+  diagnostic_info = prepare_diagnostic_information ();
+
+  gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (fatal_error_dialog),
+                                            _("You have discovered a bug in PSPP.  "
+                                              "Please report this to %s including all of the following information, "
+                                              "and a description of what you were doing when this happened."),
+                                            PACKAGE_BUGREPORT);
+
+  g_return_if_fail (fatal_error_dialog != NULL);
+
+  GtkWidget *content_area = gtk_dialog_get_content_area (GTK_DIALOG (fatal_error_dialog));
+  fatal_error_label = gtk_label_new ("");
+  g_object_set (fatal_error_label,
+                "selectable", TRUE,
+                "wrap", TRUE,
+                NULL);
+  gtk_container_add (GTK_CONTAINER (content_area), fatal_error_label);
+
+  gtk_widget_show_all (content_area);
+
+  fatal_error_action.sa_handler = fatal_error_handler;
+  fatal_error_action.sa_mask = sigset;
+  fatal_error_action.sa_flags = 0;
+
+  post_initialise (app);
+
+  GtkWindow *x = create_data_window ();
+  gtk_application_add_window (GTK_APPLICATION (app), x);
+
+  wait_for_splash (app, x);
+  sigaction (SIGABRT, &fatal_error_action, NULL);
+  sigaction (SIGSEGV, &fatal_error_action, NULL);
+  sigaction (SIGFPE,  &fatal_error_action, NULL);
+}
 
-  if (!w)
+static GtkWindow *
+find_empty_data_window (GApplication *app)
+{
+  GList *wl = gtk_application_get_windows (GTK_APPLICATION (app));
+  while (wl)
     {
-      gdk_event_free (e);
-      return TRUE;
+      if (wl->data && PSPPIRE_IS_DATA_WINDOW (GTK_WINDOW (wl->data)) &&
+          psppire_data_window_is_empty (PSPPIRE_DATA_WINDOW (wl->data)))
+        return GTK_WINDOW (wl->data);
+      wl = wl->next;
     }
+  return NULL;
+}
 
-  fill_splash_window (w, source->sfc);
-  gdk_display_flush (gdk_window_get_display (w));
-
-  gdk_event_free (e);
+static GtkWindow *
+find_psppire_window (GApplication *app)
+{
+  GList *wl = gtk_application_get_windows (GTK_APPLICATION (app));
+  while (wl)
+    {
+      if (wl->data && PSPPIRE_IS_WINDOW (GTK_WINDOW (wl->data)))
+        return GTK_WINDOW (wl->data);
+      wl = wl->next;
+    }
+  return NULL;
+}
 
-  return TRUE;
+static void
+on_open (GApplication *app, GFile **files, gint n_files, gchar * hint,
+         gpointer ud)
+{
+  /* If the application is already open and we open another file
+     via xdg-open on GNU/Linux or via the file manager, then open is
+     called. Check if we already have a psppire window. */
+  if (find_psppire_window (app) == NULL)
+    post_initialise (app);
+
+  /* When a new data file is opened, then try to find an empty
+     data window which will then be replaced as in the open file
+     dialog */
+  GtkWindow *victim = find_empty_data_window (app);
+
+  gchar *file = g_file_get_parse_name (files[0]);
+  GtkWindow *x = psppire_preload_file (file, victim);
+  g_free (file);
+
+  wait_for_splash (app, x);
 }
 
 
-gboolean
-destroy_splash_window (gpointer ud)
+/* These are arguments which must be processed BEFORE the X server has been initialised */
+static void
+process_pre_start_arguments (int *argc, char ***argv)
 {
-  GdkWindow *win = GDK_WINDOW (ud);
-  gdk_window_withdraw (win);
-  gdk_display_flush (gdk_window_get_display (win));
-  gdk_window_destroy (win);
-  
-  return FALSE;
+  GOptionEntry oe[] = {
+    {"version", 'V', G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
+     show_version_and_exit, N_("Show version information and exit"), 0},
+    {NULL, 0, 0, 0, NULL, "", 0}
+  };
+
+  GOptionContext *oc = g_option_context_new ("");
+  g_option_context_set_help_enabled (oc, FALSE);
+  g_option_context_set_ignore_unknown_options (oc, FALSE);
+  g_option_context_add_main_entries (oc, oe, NULL);
+  g_option_context_parse (oc, argc, argv, NULL);
+  g_option_context_free (oc);
 }
 
-GSourceFuncs splash_funcs = {splash_prepare, splash_check, splash_dispatch, NULL};
+int
+main (int argc, char *argv[])
+{
+  /* Some operating systems need to munge the arguments.  */
+  pre_initialisation (&argc, argv);
 
+  set_program_name (argv[0]);
 
-GdkWindow *
-create_splash_window (GMainContext *context)
-{
-  const gchar *filename = PKGDATADIR "/splash.png";
+  GtkApplication *app =
+    gtk_application_new ("gnu.pspp", G_APPLICATION_HANDLES_OPEN);
 
-  const char *relocated_filename = relocate (filename);
-  cairo_surface_t *the_surface = 
-    cairo_image_surface_create_from_png  (relocated_filename);
+  process_pre_start_arguments (&argc, &argv);
 
-  if (filename != relocated_filename)
-    free (CONST_CAST (char *, relocated_filename));
+  GOptionEntry oe[] = {
+    {"no-splash", 'q', G_OPTION_FLAG_NONE, G_OPTION_ARG_NONE, NULL,
+      N_("Do not display the splash screen"), 0},
+    {"no-unique", 'n', G_OPTION_FLAG_NONE, G_OPTION_ARG_NONE, NULL,
+      N_("Do not attempt single instance negotiation"), 0},
+    {NULL}
+  };
 
-  
-  g_return_val_if_fail (the_surface, NULL);
-    
-  int attr_mask = GDK_WA_TYPE_HINT;
-  GdkWindowAttr attr;
-    
-  attr.width =  cairo_image_surface_get_width (the_surface);
-  attr.height = cairo_image_surface_get_height (the_surface);
-  attr.wclass = GDK_INPUT_OUTPUT; 
-  attr.window_type = GDK_WINDOW_TOPLEVEL;
-    
-  attr.type_hint = GDK_WINDOW_TYPE_HINT_SPLASHSCREEN;
-    
-  GdkWindow *win = gdk_window_new (NULL, &attr, attr_mask);
-    
-  gdk_window_set_events (win, GDK_EXPOSURE_MASK);
-  gdk_window_set_keep_above (win, TRUE);
-  gdk_window_show (win);
-  
-
-  GSource *ss = g_source_new (&splash_funcs,
-			      sizeof (struct splash_source));
-  
-  ((struct splash_source *) ss)->sfc = the_surface;
-  g_source_set_priority (ss, G_PRIORITY_HIGH);
-    
-  g_source_attach (ss, context);
+  g_application_add_main_option_entries (G_APPLICATION (app), oe);
 
-  g_source_unref (ss);
-    
-  return win;
-}
+  g_signal_connect (app, "startup", G_CALLBACK (on_startup), NULL);
+  g_signal_connect (app, "activate", G_CALLBACK (on_activate), NULL);
+  g_signal_connect (app, "handle-local-options",
+                    G_CALLBACK (on_local_options), NULL);
+  g_signal_connect (app, "open", G_CALLBACK (on_open), NULL);
 
+  {
+    GSimpleAction *act_new_syntax = g_simple_action_new ("new-syntax", NULL);
+    g_signal_connect_swapped (act_new_syntax, "activate",
+                              G_CALLBACK (create_syntax_window), NULL);
+    g_action_map_add_action (G_ACTION_MAP (app), G_ACTION (act_new_syntax));
+  }
 
+  {
+    GSimpleAction *act_new_data = g_simple_action_new ("new-data", NULL);
+    g_signal_connect_swapped (act_new_data, "activate",
+                              G_CALLBACK (create_data_window), NULL);
+    g_action_map_add_action (G_ACTION_MAP (app), G_ACTION (act_new_data));
+  }
+
+  g_object_set (G_OBJECT (app), "register-session", TRUE, NULL);
+  return g_application_run (G_APPLICATION (app), argc, argv);
+}