7 files changed, 363 insertions, 325 deletions

diff --git a/src/Makefile.am b/src/Makefile.am
index 4ef161a..5a5ea4c 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -16,6 +16,8 @@ nodist_mate_calc_SOURCES= $(BUILT_SOURCES)
 
 mate_calc_SOURCES = \
 	mate-calc.c \
+	mate-calc-application.c \
+	mate-calc-application.h \
 	currency.c \
 	currency.h \
 	currency-manager.c \
diff --git a/src/mate-calc-application.c b/src/mate-calc-application.c
new file mode 100644
index 0000000..587bb27
--- /dev/null
+++ b/src/mate-calc-application.c
@@ -0,0 +1,227 @@
+/*
+ * mate-calc-application.c - GtkApplication for MATE Calculator
+ *
+ * Copyright (C) 2026 MATE Desktop Team
+ *
+ * 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 the Free Software
+ * Foundation, either version 2 of the License, or (at your option) any later
+ * version. See http://www.gnu.org/copyleft/gpl.html the full text of the
+ * license.
+ */
+
+#include <config.h>
+
+#include <string.h>
+#include <glib/gi18n.h>
+
+#include "mate-calc-application.h"
+#include "math-window.h"
+#include "mp-equation.h"
+#include "unit-manager.h"
+
+/* Global settings variable for backward compatibility with existing code */
+GSettings *g_settings_var = NULL;
+
+struct _MateCalcApplication
+{
+    GtkApplication  parent_instance;
+
+    GSettings      *settings;
+};
+
+G_DEFINE_TYPE(MateCalcApplication, mate_calc_application, GTK_TYPE_APPLICATION)
+
+static void
+mate_calc_application_startup(GApplication *application)
+{
+    MateCalcApplication *app = MATE_CALC_APPLICATION(application);
+
+    G_APPLICATION_CLASS(mate_calc_application_parent_class)->startup(application);
+
+    /* Initialize settings */
+    app->settings = g_settings_new("org.mate.calc");
+    g_settings_var = app->settings;
+}
+
+static void
+mate_calc_application_activate(GApplication *application)
+{
+    MateCalcApplication *app = MATE_CALC_APPLICATION(application);
+    MathEquation *equation;
+    GtkWindow *window;
+    MathButtons *buttons;
+    gint accuracy, word_size, base;
+    gboolean show_tsep, show_zeroes, show_hist;
+    MpDisplayFormat number_format;
+    MPAngleUnit angle_units;
+    ButtonMode button_mode;
+    gchar *source_currency, *target_currency;
+    gchar *source_units, *target_units;
+
+    accuracy = g_settings_get_int(app->settings, "accuracy");
+    word_size = g_settings_get_int(app->settings, "word-size");
+    base = g_settings_get_int(app->settings, "base");
+    show_tsep = g_settings_get_boolean(app->settings, "show-thousands");
+    show_zeroes = g_settings_get_boolean(app->settings, "show-zeroes");
+    show_hist = g_settings_get_boolean(app->settings, "show-history");
+    number_format = g_settings_get_enum(app->settings, "number-format");
+    angle_units = g_settings_get_enum(app->settings, "angle-units");
+    button_mode = g_settings_get_enum(app->settings, "button-mode");
+    source_currency = g_settings_get_string(app->settings, "source-currency");
+    target_currency = g_settings_get_string(app->settings, "target-currency");
+    source_units = g_settings_get_string(app->settings, "source-units");
+    target_units = g_settings_get_string(app->settings, "target-units");
+
+    equation = math_equation_new();
+    math_equation_set_accuracy(equation, accuracy);
+    math_equation_set_word_size(equation, word_size);
+    math_equation_set_show_thousands_separators(equation, show_tsep);
+    math_equation_set_show_trailing_zeroes(equation, show_zeroes);
+    math_equation_set_number_format(equation, number_format);
+    math_equation_set_angle_units(equation, angle_units);
+    math_equation_set_source_currency(equation, source_currency);
+    math_equation_set_target_currency(equation, target_currency);
+    math_equation_set_source_units(equation, source_units);
+    math_equation_set_target_units(equation, target_units);
+    g_free(source_currency);
+    g_free(target_currency);
+    g_free(source_units);
+    g_free(target_units);
+
+    window = GTK_WINDOW(math_window_new(equation));
+    gtk_application_add_window(GTK_APPLICATION(app), window);
+
+    buttons = math_window_get_buttons(MATH_WINDOW(window));
+
+    math_window_set_show_history(MATH_WINDOW(window), show_hist);
+    math_buttons_set_programming_base(buttons, base);
+    math_buttons_set_mode(buttons, button_mode);
+
+    gtk_widget_show(GTK_WIDGET(window));
+}
+
+static void
+mate_calc_application_shutdown(GApplication *application)
+{
+    MateCalcApplication *app = MATE_CALC_APPLICATION(application);
+
+    g_settings_var = NULL;
+    g_clear_object(&app->settings);
+
+    G_APPLICATION_CLASS(mate_calc_application_parent_class)->shutdown(application);
+}
+
+static int
+do_convert(const MPNumber *x, const char *x_units, const char *z_units, MPNumber *z, void *data)
+{
+    return unit_manager_convert_by_symbol(unit_manager_get_default(), x, x_units, z_units, z);
+}
+
+static gint
+mate_calc_application_handle_local_options(GApplication *application,
+                                            GVariantDict *options)
+{
+    if (g_variant_dict_contains(options, "version"))
+    {
+        g_print("%s %s\n", "mate-calc", VERSION);
+        return 0;
+    }
+
+    const gchar *solve_expr = NULL;
+    if (g_variant_dict_lookup(options, "solve", "&s", &solve_expr))
+    {
+        /* Solve mode - handled locally without initializing the full GUI */
+        MPEquationOptions mp_options;
+        MPErrorCode error;
+        MPNumber result = mp_new();
+        char *result_str;
+
+        memset(&mp_options, 0, sizeof(mp_options));
+        mp_options.base = 10;
+        mp_options.wordlen = 32;
+        mp_options.angle_units = MP_DEGREES;
+        mp_options.convert = do_convert;
+
+        error = mp_equation_parse(solve_expr, &mp_options, &result, NULL);
+
+        if (error == PARSER_ERR_MP)
+        {
+            g_printerr("Error: %s\n", mp_get_error());
+            mp_clear(&result);
+            return 1;
+        }
+        else if (error != 0)
+        {
+            g_printerr("Error: %s\n", mp_error_code_to_string(error));
+            mp_clear(&result);
+            return 1;
+        }
+        else
+        {
+            MpSerializer *serializer = mp_serializer_new(MP_DISPLAY_FORMAT_AUTOMATIC, 10, 9);
+            result_str = mp_serializer_to_string(serializer, &result);
+            g_print("%s\n", result_str);
+            g_free(result_str);
+            g_object_unref(serializer);
+            mp_clear(&result);
+            return 0;
+        }
+    }
+
+    /* Let the default handler continue */
+    return -1;
+}
+
+static gint
+mate_calc_application_command_line(GApplication            *application,
+                                    GApplicationCommandLine *command_line)
+{
+    /* Activate normal GUI mode */
+    g_application_activate(application);
+
+    return 0;
+}
+
+static void
+mate_calc_application_init(MateCalcApplication *app)
+{
+    /* Command line options */
+    const GOptionEntry options[] = {
+        { "version", 'v', G_OPTION_FLAG_NONE, G_OPTION_ARG_NONE, NULL,
+          N_("Show release version"), NULL },
+        { "solve", 's', G_OPTION_FLAG_NONE, G_OPTION_ARG_STRING, NULL,
+          N_("Solve the given equation"), N_("EQUATION") },
+        { NULL }
+    };
+
+    g_application_add_main_option_entries(G_APPLICATION(app), options);
+}
+
+static void
+mate_calc_application_class_init(MateCalcApplicationClass *klass)
+{
+    GApplicationClass *app_class = G_APPLICATION_CLASS(klass);
+
+    app_class->startup = mate_calc_application_startup;
+    app_class->activate = mate_calc_application_activate;
+    app_class->shutdown = mate_calc_application_shutdown;
+    app_class->handle_local_options = mate_calc_application_handle_local_options;
+    app_class->command_line = mate_calc_application_command_line;
+}
+
+MateCalcApplication *
+mate_calc_application_new(void)
+{
+    return g_object_new(MATE_CALC_TYPE_APPLICATION,
+                        "application-id", "org.mate.Calculator",
+                        "flags", G_APPLICATION_HANDLES_COMMAND_LINE,
+                        NULL);
+}
+
+GSettings *
+mate_calc_application_get_settings(MateCalcApplication *app)
+{
+    g_return_val_if_fail(MATE_CALC_IS_APPLICATION(app), NULL);
+    return app->settings;
+}
diff --git a/src/mate-calc-application.h b/src/mate-calc-application.h
new file mode 100644
index 0000000..b8ec26d
--- /dev/null
+++ b/src/mate-calc-application.h
@@ -0,0 +1,44 @@
+/*
+ * mate-calc-application.h - GtkApplication for MATE Calculator
+ *
+ * Copyright (C) 2026 MATE Desktop Team
+ *
+ * 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 the Free Software
+ * Foundation, either version 2 of the License, or (at your option) any later
+ * version. See http://www.gnu.org/copyleft/gpl.html the full text of the
+ * license.
+ */
+
+#ifndef MATE_CALC_APPLICATION_H
+#define MATE_CALC_APPLICATION_H
+
+#include <gtk/gtk.h>
+
+G_BEGIN_DECLS
+
+#define MATE_CALC_TYPE_APPLICATION (mate_calc_application_get_type())
+G_DECLARE_FINAL_TYPE(MateCalcApplication, mate_calc_application, MATE_CALC, APPLICATION, GtkApplication)
+
+/**
+ * mate_calc_application_new:
+ *
+ * Creates a new MateCalcApplication instance.
+ *
+ * Returns: (transfer full): A new MateCalcApplication
+ */
+MateCalcApplication *mate_calc_application_new(void);
+
+/**
+ * mate_calc_application_get_settings:
+ * @app: A MateCalcApplication
+ *
+ * Gets the GSettings object for the calculator.
+ *
+ * Returns: (transfer none): The GSettings object
+ */
+GSettings *mate_calc_application_get_settings(MateCalcApplication *app);
+
+G_END_DECLS
+
+#endif /* MATE_CALC_APPLICATION_H */
diff --git a/src/mate-calc.c b/src/mate-calc.c
index a3eb87c..dfeb726 100644
--- a/src/mate-calc.c
+++ b/src/mate-calc.c
@@ -1,6 +1,7 @@
 /*
  * Copyright (C) 1987-2008 Sun Microsystems, Inc. All Rights Reserved.
  * Copyright (C) 2008-2011 Robert Ancell
+ * Copyright (C) 2011-2026 MATE Desktop Team
  *
  * 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 the Free Software
@@ -9,256 +10,33 @@
  * license.
  */
 
-#ifdef HAVE_CONFIG_H
 #include <config.h>
-#endif
 
 #include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
 #include <locale.h>
 #include <glib/gi18n.h>
 
-#include "math-window.h"
-#include "math-preferences.h"
-#include "mp-equation.h"
-#include "unit-manager.h"
-#include "utility.h"
+#include "mate-calc-application.h"
 
-GSettings *g_settings_var = NULL;
-
-static MathWindow *window;
-
-static void
-version(const gchar *progname)
-{
-    /* NOTE: Is not translated so can be easily parsed */
-    fprintf(stderr, "%1$s %2$s\n", progname, VERSION);
-}
-
-static int
-do_convert(const MPNumber *x, const char *x_units, const char *z_units, MPNumber *z, void *data)
-{
-    return unit_manager_convert_by_symbol(unit_manager_get_default(), x, x_units, z_units, z);
-}
-
-static void
-solve(const char *equation)
-{
-    MPEquationOptions options;
-    MPErrorCode error;
-    MPNumber result = mp_new();
-    char *result_str;
-
-    memset(&options, 0, sizeof(options));
-    options.base = 10;
-    options.wordlen = 32;
-    options.angle_units = MP_DEGREES;
-    options.convert = do_convert;
-
-    error = mp_equation_parse(equation, &options, &result, NULL);
-    if(error == PARSER_ERR_MP) {
-        fprintf(stderr, "Error: %s\n", mp_get_error());
-        mp_clear(&result);
-        exit(1);
-    }
-    else if(error != 0) {
-        fprintf(stderr, "Error: %s\n", mp_error_code_to_string(error));
-        mp_clear(&result);
-        exit(1);
-    }
-    else {
-        MpSerializer *serializer = mp_serializer_new(MP_DISPLAY_FORMAT_AUTOMATIC, 10, 9);
-        result_str = mp_serializer_to_string(serializer, &result);
-        g_object_unref(serializer);
-        printf("%s\n", result_str);
-        g_free(result_str);
-        mp_clear(&result);
-        exit(0);
-    }
-}
-
-static void
-usage(const gchar *progname, gboolean show_application, gboolean show_gtk)
-{
-    fprintf(stderr,
-            /* Description on how to use mate-calc displayed on command-line */
-            _("Usage:\n"
-              "  %s — Perform mathematical calculations"), progname);
-
-    fprintf(stderr,
-            "\n\n");
-
-    fprintf(stderr,
-            /* Description on mate-calc command-line help options displayed on command-line */
-            _("Help Options:\n"
-              "  -v, --version                   Show release version\n"
-              "  -h, -?, --help                  Show help options\n"
-              "  --help-all                      Show all help options\n"
-              "  --help-gtk                      Show GTK+ options"));
-    fprintf(stderr,
-            "\n\n");
-
-    if (show_gtk) {
-        fprintf(stderr,
-                /* Description on mate-calc command-line GTK+ options displayed on command-line */
-                _("GTK+ Options:\n"
-                  "  --class=CLASS                   Program class as used by the window manager\n"
-                  "  --name=NAME                     Program name as used by the window manager\n"
-                  "  --screen=SCREEN                 X screen to use\n"
-                  "  --sync                          Make X calls synchronous\n"
-                  "  --gtk-module=MODULES            Load additional GTK+ modules\n"
-                  "  --g-fatal-warnings              Make all warnings fatal"));
-        fprintf(stderr,
-                "\n\n");
-    }
-
-    if (show_application) {
-        fprintf(stderr,
-                /* Description on mate-calc application options displayed on command-line */
-                _("Application Options:\n"
-                  "  -s, --solve <equation>          Solve the given equation"));
-        fprintf(stderr,
-                "\n\n");
-    }
-}
-
-static void
-get_options(int argc, char *argv[])
-{
-    int i;
-    char *progname, *arg;
-
-    progname = g_path_get_basename(argv[0]);
-
-    for (i = 1; i < argc; i++) {
-        arg = argv[i];
-
-        if (strcmp(arg, "-v") == 0 ||
-            strcmp(arg, "--version") == 0) {
-            version(progname);
-            g_free(progname);
-            exit(0);
-        }
-        else if (strcmp(arg, "-h") == 0 ||
-                 strcmp(arg, "-?") == 0 ||
-                 strcmp(arg, "--help") == 0) {
-            usage(progname, TRUE, FALSE);
-            g_free(progname);
-            exit(0);
-        }
-        else if (strcmp(arg, "--help-all") == 0) {
-            usage(progname, TRUE, TRUE);
-            g_free(progname);
-            exit(0);
-        }
-        else if (strcmp(arg, "--help-gtk") == 0) {
-            usage(progname, FALSE, TRUE);
-            g_free(progname);
-            exit(0);
-        }
-        else if (strcmp(arg, "-s") == 0 ||
-            strcmp(arg, "--solve") == 0) {
-            i++;
-            if (i >= argc) {
-                fprintf(stderr,
-                        /* Error printed to stderr when user uses --solve argument without an equation */
-                        _("Argument --solve requires an equation to solve"));
-                fprintf(stderr, "\n");
-                g_free(progname);
-                exit(1);
-            }
-            else {
-                g_free(progname);
-                solve(argv[i]);
-            }
-        }
-        else {
-            fprintf(stderr,
-                    /* Error printed to stderr when user provides an unknown command-line argument */
-                    _("Unknown argument '%s'"), arg);
-            fprintf(stderr, "\n");
-            usage(progname, TRUE, FALSE);
-            g_free(progname);
-            exit(1);
-        }
-    }
-
-    g_free(progname);
-}
-
-static void
-quit_cb(MathWindow *win)
+int
+main(int argc, char **argv)
 {
-    gtk_main_quit();
-}
-
-int main(int argc, char **argv)
-{
-    MathEquation *equation;
-    MathButtons *buttons;
-    int accuracy = 9, word_size = 64, base = 10;
-    gboolean show_tsep = FALSE, show_zeroes = FALSE, show_hist = FALSE;
-    MpDisplayFormat number_format;
-    MPAngleUnit angle_units;
-    ButtonMode button_mode;
-    gchar *source_currency, *target_currency;
-    gchar *source_units, *target_units;
+    MateCalcApplication *app;
+    int status;
 
+    /* Locale setup */
     setlocale(LC_ALL, "");
     bindtextdomain(GETTEXT_PACKAGE, LOCALE_DIR);
     bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
     textdomain(GETTEXT_PACKAGE);
 
-    /* Seed random number generator. */
-    srand48((long) time((time_t *) 0));
-
-    gtk_init(&argc, &argv);
-
-    g_settings_var = g_settings_new ("org.mate.calc");
-    accuracy = g_settings_get_int(g_settings_var, "accuracy");
-    word_size = g_settings_get_int(g_settings_var, "word-size");
-    base = g_settings_get_int(g_settings_var, "base");
-    show_tsep = g_settings_get_boolean(g_settings_var, "show-thousands");
-    show_zeroes = g_settings_get_boolean(g_settings_var, "show-zeroes");
-    show_hist = g_settings_get_boolean(g_settings_var, "show-history");
-    number_format = g_settings_get_enum(g_settings_var, "number-format");
-    angle_units = g_settings_get_enum(g_settings_var, "angle-units");
-    button_mode = g_settings_get_enum(g_settings_var, "button-mode");
-    source_currency = g_settings_get_string(g_settings_var, "source-currency");
-    target_currency = g_settings_get_string(g_settings_var, "target-currency");
-    source_units = g_settings_get_string(g_settings_var, "source-units");
-    target_units = g_settings_get_string(g_settings_var, "target-units");
-
-    equation = math_equation_new();
-    math_equation_set_accuracy(equation, accuracy);
-    math_equation_set_word_size(equation, word_size);
-    math_equation_set_show_thousands_separators(equation, show_tsep);
-    math_equation_set_show_trailing_zeroes(equation, show_zeroes);
-    math_equation_set_number_format(equation, number_format);
-    math_equation_set_angle_units(equation, angle_units);
-    math_equation_set_source_currency(equation, source_currency);
-    math_equation_set_target_currency(equation, target_currency);
-    math_equation_set_source_units(equation, source_units);
-    math_equation_set_target_units(equation, target_units);
-    g_free(source_currency);
-    g_free(target_currency);
-    g_free(source_units);
-    g_free(target_units);
-
-    get_options(argc, argv);
-
-    //gtk_window_set_default_icon_name("accessories-calculator");
-
-    window = math_window_new(equation);
-    buttons = math_window_get_buttons(window);
-    g_signal_connect(G_OBJECT(window), "quit", G_CALLBACK(quit_cb), NULL);
-    math_window_set_show_history(window, show_hist);
-    math_buttons_set_programming_base(buttons, base);
-    math_buttons_set_mode(buttons, button_mode); // FIXME: We load the basic buttons even if we immediately switch to the next type
+    /* Seed random number generator */
+    srand48((long)time((time_t *)0));
 
-    gtk_widget_show(GTK_WIDGET(window));
-    gtk_main();
+    /* Create and run application */
+    app = mate_calc_application_new();
+    status = g_application_run(G_APPLICATION(app), argc, argv);
+    g_object_unref(app);
 
-    return 0;
+    return status;
 }
diff --git a/src/math-window.c b/src/math-window.c
index 320f83b..7e021fb 100644
--- a/src/math-window.c
+++ b/src/math-window.c
@@ -1,6 +1,7 @@
 /*
  * Copyright (C) 1987-2008 Sun Microsystems, Inc. All Rights Reserved.
  * Copyright (C) 2008-2011 Robert Ancell.
+ * Copyright (C) 2011-2026 MATE Desktop Team
  *
  * 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 the Free Software
@@ -16,6 +17,7 @@
 #include <glib/gi18n.h>
 #include <gtk/gtk.h>
 #include <gdk/gdkkeysyms.h>
+#include <mpc.h>
 
 #include "math-window.h"
 #include "math-history.h"
@@ -57,15 +59,7 @@ struct MathWindowPrivate
     GtkWidget *view_history_menu_item;
 };
 
-G_DEFINE_TYPE_WITH_PRIVATE (MathWindow, math_window, GTK_TYPE_WINDOW);
-
-enum
-{
-    QUIT,
-    LAST_SIGNAL
-};
-
-static guint signals[LAST_SIGNAL] = { 0, };
+G_DEFINE_TYPE_WITH_PRIVATE(MathWindow, math_window, GTK_TYPE_APPLICATION_WINDOW);
 
 MathWindow *
 math_window_new(MathEquation *equation)
@@ -135,22 +129,28 @@ void
 math_window_critical_error(MathWindow *window, const gchar *title, const gchar *contents)
 {
     GtkWidget *dialog;
+    GtkApplication *app;
 
     g_return_if_fail(window != NULL);
     g_return_if_fail(title != NULL);
     g_return_if_fail(contents != NULL);
 
-    dialog = gtk_message_dialog_new(NULL, 0,
+    dialog = gtk_message_dialog_new(GTK_WINDOW(window),
+                                    GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
                                     GTK_MESSAGE_ERROR,
                                     GTK_BUTTONS_NONE,
                                     "%s", title);
     gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog),
                                              "%s", contents);
-    gtk_dialog_add_buttons(GTK_DIALOG(dialog), "gtk-quit", GTK_RESPONSE_ACCEPT, NULL);
+    gtk_dialog_add_buttons(GTK_DIALOG(dialog), _("_Quit"), GTK_RESPONSE_ACCEPT, NULL);
 
     gtk_dialog_run(GTK_DIALOG(dialog));
+    gtk_widget_destroy(dialog);
 
-    g_signal_emit(window, signals[QUIT], 0);
+    /* Critical error - quit the entire application */
+    app = gtk_window_get_application(GTK_WINDOW(window));
+    if (app)
+        g_application_quit(G_APPLICATION(app));
 }
 
 static void mode_changed_cb(GtkWidget *menu, MathWindow *window)
@@ -198,64 +198,6 @@ static void show_preferences_cb(GtkMenuItem *menu, MathWindow *window)
     gtk_window_present(GTK_WINDOW(window->priv->preferences_dialog));
 }
 
-static gboolean
-key_press_cb(MathWindow *window, GdkEventKey *event)
-{
-    gboolean result;
-    g_signal_emit_by_name(window->priv->display, "key-press-event", event, &result);
-
-    /* Keyboard navigation for history */
-    if ((event->state & GDK_MOD1_MASK) == GDK_MOD1_MASK && (event->keyval == GDK_KEY_Up || event->keyval == GDK_KEY_Down))
-    {
-        switch (event->keyval)
-        {
-            case GDK_KEY_Up:
-                math_history_set_current(window->priv->history, -1);
-                break;
-            case GDK_KEY_Down:
-                math_history_set_current(window->priv->history, 1);
-                break;
-        }
-
-        MathHistoryEntry *entry = math_history_get_entry_at(window->priv->history, math_history_get_current(window->priv->history));
-        if (entry)
-        {
-            gchar *equation_string = math_history_entry_get_equation(entry);
-            math_equation_set(window->priv->equation, equation_string);
-            g_free(equation_string);
-        }
-        return TRUE;
-    }
-    else if (math_buttons_get_mode (window->priv->buttons) == PROGRAMMING && (event->state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK) {
-        switch(event->keyval)
-        {
-        /* Binary */
-        case GDK_KEY_b:
-            math_equation_set_base (window->priv->equation, 2);
-            return TRUE;
-        /* Octal */
-        case GDK_KEY_o:
-            math_equation_set_base (window->priv->equation, 8);
-            return TRUE;
-        /* Decimal */
-        case GDK_KEY_d:
-            math_equation_set_base (window->priv->equation, 10);
-            return TRUE;
-        /* Hexdecimal */
-        case GDK_KEY_h:
-            math_equation_set_base (window->priv->equation, 16);
-            return TRUE;
-        }
-    }
-
-    return result;
-}
-
-static void delete_cb(MathWindow *window, GdkEvent *event)
-{
-    g_signal_emit(window, signals[QUIT], 0);
-}
-
 static void copy_cb(GtkWidget *widget, MathWindow *window)
 {
     math_equation_copy(window->priv->equation);
@@ -384,6 +326,65 @@ static void about_cb(GtkWidget* widget, MathWindow* window)
     g_free (license_trans);
 }
 
+static void quit_cb(GtkWidget* widget, MathWindow* window)
+{
+    gtk_widget_destroy(GTK_WIDGET(window));
+}
+
+static gboolean
+key_press_cb(MathWindow *window, GdkEventKey *event)
+{
+    gboolean result;
+    g_signal_emit_by_name(window->priv->display, "key-press-event", event, &result);
+
+    /* Keyboard navigation for history */
+    if ((event->state & GDK_MOD1_MASK) == GDK_MOD1_MASK && (event->keyval == GDK_KEY_Up || event->keyval == GDK_KEY_Down))
+    {
+        switch (event->keyval)
+        {
+            case GDK_KEY_Up:
+                math_history_set_current(window->priv->history, -1);
+                break;
+            case GDK_KEY_Down:
+                math_history_set_current(window->priv->history, 1);
+                break;
+        }
+
+        MathHistoryEntry *entry = math_history_get_entry_at(window->priv->history, math_history_get_current(window->priv->history));
+        if (entry)
+        {
+            gchar *equation_string = math_history_entry_get_equation(entry);
+            math_equation_set(window->priv->equation, equation_string);
+            g_free(equation_string);
+        }
+        return TRUE;
+    }
+    else if (math_buttons_get_mode (window->priv->buttons) == PROGRAMMING && (event->state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK) {
+        switch(event->keyval)
+        {
+        /* Binary */
+        case GDK_KEY_b:
+            math_equation_set_base (window->priv->equation, 2);
+            return TRUE;
+        /* Octal */
+        case GDK_KEY_o:
+            math_equation_set_base (window->priv->equation, 8);
+            return TRUE;
+        /* Decimal */
+        case GDK_KEY_d:
+            math_equation_set_base (window->priv->equation, 10);
+            return TRUE;
+        /* Hexdecimal */
+        case GDK_KEY_h:
+            math_equation_set_base (window->priv->equation, 16);
+            return TRUE;
+        }
+    }
+
+    return result;
+}
+
+
 static void
 scroll_changed_cb(GtkAdjustment *adjustment, MathWindow *window)
 {
@@ -454,11 +455,6 @@ history_set_serializer_cb(MathEquation *equation, MathWindow *window)
     math_history_set_serializer(window->priv->history, serializer);
 }
 
-static void quit_cb(GtkWidget* widget, MathWindow* window)
-{
-    g_signal_emit(window, signals[QUIT], 0);
-}
-
 static GtkWidget *add_menu_item(GtkWidget *menu, GtkWidget *menu_item, GCallback callback, gpointer callback_data)
 {
     gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);
@@ -697,14 +693,6 @@ math_window_class_init(MathWindowClass *klass)
                                                          "Show-history",
                                                          FALSE,
                                                          G_PARAM_READWRITE));
-
-    signals[QUIT] = g_signal_new("quit",
-                                 G_TYPE_FROM_CLASS (klass),
-                                 G_SIGNAL_RUN_LAST,
-                                 G_STRUCT_OFFSET (MathWindowClass, quit),
-                                 NULL, NULL,
-                                 g_cclosure_marshal_VOID__VOID,
-                                 G_TYPE_NONE, 0);
 }
 
 static void
@@ -718,5 +706,4 @@ math_window_init(MathWindow *window)
     gtk_window_set_role(GTK_WINDOW(window), "mate-calc");
     gtk_window_set_resizable(GTK_WINDOW(window), FALSE);
     g_signal_connect_after(G_OBJECT(window), "key-press-event", G_CALLBACK(key_press_cb), NULL);
-    g_signal_connect(G_OBJECT(window), "delete-event", G_CALLBACK(delete_cb), NULL);
 }
diff --git a/src/math-window.h b/src/math-window.h
index 72f19bc..0a8f97f 100644
--- a/src/math-window.h
+++ b/src/math-window.h
@@ -1,6 +1,7 @@
 /*
  * Copyright (C) 1987-2008 Sun Microsystems, Inc. All Rights Reserved.
  * Copyright (C) 2008-2011 Robert Ancell.
+ * Copyright (C) 2011-2026 MATE Desktop Team
  *
  * 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 the Free Software
@@ -12,7 +13,7 @@
 #ifndef MATH_WINDOW_H
 #define MATH_WINDOW_H
 
-#include <glib-object.h>
+#include <gtk/gtk.h>
 #include "math-equation.h"
 #include "math-display.h"
 #include "math-buttons.h"
@@ -26,15 +27,13 @@ typedef struct MathWindowPrivate MathWindowPrivate;
 
 typedef struct
 {
-    GtkWindow parent_instance;
+    GtkApplicationWindow parent_instance;
     MathWindowPrivate *priv;
 } MathWindow;
 
 typedef struct
 {
-    GtkWindowClass parent_class;
-
-    void (*quit) (MathWindow *window);
+    GtkApplicationWindowClass parent_class;
 } MathWindowClass;
 
 GType math_window_get_type(void);
diff --git a/src/meson.build b/src/meson.build
index bb183cd..f6a5396 100644
--- a/src/meson.build
+++ b/src/meson.build
@@ -25,6 +25,7 @@ ui_resources = gnome.compile_resources(
 
 src += [
     'mate-calc.c',
+    'mate-calc-application.c',
     'currency-manager.c',
     'currency.c',
     'financial.c',