src/math-window.c

   1 /*
   2  * Copyright (C) 1987-2008 Sun Microsystems, Inc. All Rights Reserved.
   3  * Copyright (C) 2008-2011 Robert Ancell.
   4  *
   5  * This program is free software: you can redistribute it and/or modify it under
   6  * the terms of the GNU General Public License as published by the Free Software
   7  * Foundation, either version 2 of the License, or (at your option) any later
   8  * version. See http://www.gnu.org/copyleft/gpl.html the full text of the
   9  * license.
  10  */
  11
  12 #include <glib/gi18n.h>
  13 #include <gtk/gtk.h>
  14 #include <gdk/gdkkeysyms.h>
  15
  16 #include "math-window.h"
  17 #include "math-preferences.h"
  18
  19 enum {
  20     PROP_0,
  21     PROP_EQUATION
  22 };
  23
  24 struct MathWindowPrivate
  25 {
  26     GtkWidget *menu_bar;
  27     MathEquation *equation;
  28     MathDisplay *display;
  29     MathButtons *buttons;
  30     MathPreferencesDialog *preferences_dialog;
  31     gboolean right_aligned;
  32     GtkWidget *mode_basic_menu_item, *mode_advanced_menu_item, *mode_financial_menu_item, *mode_programming_menu_item;
  33 };
  34
  35 G_DEFINE_TYPE (MathWindow, math_window, GTK_TYPE_WINDOW);
  36
  37 enum {
  38     QUIT,
  39     LAST_SIGNAL
  40 };
  41 static guint signals[LAST_SIGNAL] = { 0, };
  42
  43
  44 MathWindow *
  45 math_window_new(MathEquation *equation)
  46 {
  47     return g_object_new(math_window_get_type(), "equation", equation, NULL);
  48 }
  49
  50
  51 GtkWidget *
  52 math_window_get_menu_bar(MathWindow *window)
  53 {
  54    return window->priv->menu_bar;
  55 }
  56
  57
  58 MathEquation *
  59 math_window_get_equation(MathWindow *window)
  60 {
  61     return window->priv->equation;
  62 }
  63
  64
  65 MathDisplay *
  66 math_window_get_display(MathWindow *window)
  67 {
  68     return window->priv->display;
  69 }
  70
  71
  72 MathButtons *
  73 math_window_get_buttons(MathWindow *window)
  74 {
  75     return window->priv->buttons;
  76 }
  77
  78
  79 void
  80 math_window_critical_error(MathWindow *window, const gchar *title, const gchar *contents)
  81 {
  82     GtkWidget *dialog;
  83
  84     dialog = gtk_message_dialog_new(NULL, 0,
  85                                     GTK_MESSAGE_ERROR,
  86                                     GTK_BUTTONS_NONE,
  87                                     "%s", title);
  88     gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog),
  89                                              "%s", contents);
  90     gtk_dialog_add_buttons(GTK_DIALOG(dialog), GTK_STOCK_QUIT, GTK_RESPONSE_ACCEPT, NULL);
  91
  92     gtk_dialog_run(GTK_DIALOG(dialog));
  93
  94     g_signal_emit(window, signals[QUIT], 0);
  95 }
  96
  97
  98 static void
  99 copy_cb(GtkWidget *widget, MathWindow *window)
 100 {
 101     math_equation_copy(window->priv->equation);
 102 }
 103
 104
 105 static void
 106 paste_cb(GtkWidget *widget, MathWindow *window)
 107 {
 108     math_equation_paste(window->priv->equation);
 109 }
 110
 111
 112 static void
 113 undo_cb(GtkWidget *widget, MathWindow *window)
 114 {
 115     math_equation_undo(window->priv->equation);
 116 }
 117
 118
 119 static void
 120 redo_cb(GtkWidget *widget, MathWindow *window)
 121 {
 122     math_equation_redo(window->priv->equation);
 123 }
 124
 125
 126 static void
 127 mode_changed_cb(GtkWidget *menu, MathWindow *window)
 128 {
 129     int mode;
 130
 131     if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menu)))
 132         return;
 133
 134     mode = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(menu), "calcmode"));
 135     math_buttons_set_mode(window->priv->buttons, mode);
 136 }
 137
 138
 139 static void
 140 show_preferences_cb(GtkMenuItem *menu, MathWindow *window)
 141 {
 142     if (!window->priv->preferences_dialog) {
 143         window->priv->preferences_dialog = math_preferences_dialog_new(window->priv->equation);
 144         gtk_window_set_transient_for(GTK_WINDOW(window->priv->preferences_dialog), GTK_WINDOW(window));
 145     }
 146     gtk_window_present(GTK_WINDOW(window->priv->preferences_dialog));
 147 }
 148
 149
 150 static void
 151 help_cb(GtkWidget *widget, MathWindow *window)
 152 {
 153     GdkScreen *screen;
 154     GError *error = NULL;
 155
 156     screen = gtk_widget_get_screen(GTK_WIDGET(window));
 157     gtk_show_uri(screen, "ghelp:gcalctool", gtk_get_current_event_time(), &error);
 158
 159     if (error != NULL)
 160     {
 161         GtkWidget *d;
 162         /* Translators: Error message displayed when unable to launch help browser */
 163         const char *message = _("Unable to open help file");
 164
 165         d = gtk_message_dialog_new(GTK_WINDOW (window),
 166                                    GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
 167                                    GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE,
 168                                    "%s", message);
 169         gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG (d),
 170                                                  "%s", error->message);
 171         g_signal_connect(d, "response", G_CALLBACK(gtk_widget_destroy), NULL);
 172         gtk_window_present(GTK_WINDOW(d));
 173
 174         g_error_free(error);
 175     }
 176 }
 177
 178
 179 static void
 180 about_cb(GtkWidget *widget, MathWindow *window)
 181 {
 182     const gchar *authors[] = {
 183         "Rich Burridge <rich.burridge@gmail.com>",
 184         "Robert Ancell <robert.ancell@gmail.com>",
 185         "Klaus Niederkrüger <kniederk@umpa.ens-lyon.fr>",
 186         "Robin Sonefors <ozamosi@flukkost.nu>",
 187         NULL
 188     };
 189     const gchar *documenters[] = {
 190         "Sun Microsystems",
 191         NULL
 192     };
 193
 194     /* The translator credits. Please translate this with your name(s). */
 195     const gchar *translator_credits = _("translator-credits");
 196
 197     /* The license this software is under (GPL2+) */
 198     char *license = _("Gcalctool is free software; you can redistribute it and/or modify\n"
 199           "it under the terms of the GNU General Public License as published by\n"
 200           "the Free Software Foundation; either version 2 of the License, or\n"
 201           "(at your option) any later version.\n"
 202           "\n"
 203           "Gcalctool is distributed in the hope that it will be useful,\n"
 204           "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 205           "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 206           "GNU General Public License for more details.\n"
 207           "\n"
 208           "You should have received a copy of the GNU General Public License\n"
 209           "along with Gcalctool; if not, write to the Free Software Foundation, Inc.,\n"
 210           "51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA");
 211
 212     gtk_show_about_dialog(GTK_WINDOW(window),
 213                           "name",
 214                           /* Program name in the about dialog */
 215                           _("Gcalctool"),
 216                           "version", VERSION,
 217                           "copyright",
 218                           /* Copyright notice in the about dialog */
 219                           _("\xc2\xa9 1986–2010 The Gcalctool authors"),
 220                           "license", license,
 221                           "comments",
 222                           /* Short description in the about dialog */
 223                           _("Calculator with financial and scientific modes."),
 224                           "authors", authors,
 225                           "documenters", documenters,
 226                           "translator_credits", translator_credits,
 227                           "logo-icon-name", "accessories-calculator",
 228                           NULL);
 229 }
 230
 231
 232 static void
 233 quit_cb(GtkWidget *widget, MathWindow *window)
 234 {
 235     g_signal_emit(window, signals[QUIT], 0);
 236 }
 237
 238
 239 static gboolean
 240 key_press_cb(MathWindow *window, GdkEventKey *event)
 241 {
 242     gboolean result;
 243     g_signal_emit_by_name(window->priv->display, "key-press-event", event, &result);
 244     return result;
 245 }
 246
 247
 248 static void
 249 delete_cb(MathWindow *window, GdkEvent *event)
 250 {
 251     g_signal_emit(window, signals[QUIT], 0);
 252 }
 253
 254
 255 static void
 256 scroll_changed_cb(GtkAdjustment *adjustment, MathWindow *window)
 257 {
 258     if (window->priv->right_aligned)
 259         gtk_adjustment_set_value(adjustment, gtk_adjustment_get_upper(adjustment) - gtk_adjustment_get_page_size(adjustment));
 260 }
 261
 262
 263 static void
 264 scroll_value_changed_cb(GtkAdjustment *adjustment, MathWindow *window)
 265 {
 266     if (gtk_adjustment_get_value(adjustment) == gtk_adjustment_get_upper(adjustment) - gtk_adjustment_get_page_size(adjustment))
 267         window->priv->right_aligned = TRUE;
 268     else
 269         window->priv->right_aligned = FALSE;
 270 }
 271
 272
 273 static void
 274 button_mode_changed_cb(MathButtons *buttons, GParamSpec *spec, MathWindow *window)
 275 {
 276     GtkWidget *menu;
 277
 278     switch(math_buttons_get_mode(buttons))
 279     {
 280     default:
 281     case BASIC:
 282       menu = window->priv->mode_basic_menu_item;
 283       //FIXME: Should it revert to decimal mode? math_equation_set_number_format(window->priv->equation, DEC);
 284       break;
 285
 286     case ADVANCED:
 287       menu = window->priv->mode_advanced_menu_item;
 288       break;
 289
 290     case FINANCIAL:
 291       menu = window->priv->mode_financial_menu_item;
 292       break;
 293
 294     case PROGRAMMING:
 295       menu = window->priv->mode_programming_menu_item;
 296       break;
 297     }
 298     gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menu), TRUE);
 299 }
 300
 301
 302 static GtkWidget *
 303 add_menu(GtkWidget *menu_bar, const gchar *name)
 304 {
 305     GtkWidget *menu_item, *menu;
 306
 307     menu_item = gtk_menu_item_new_with_mnemonic(name);
 308     gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), menu_item);
 309     gtk_widget_show(menu_item);
 310     menu = gtk_menu_new();
 311     gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_item), menu);
 312
 313     return menu;
 314 }
 315
 316
 317 static GtkWidget *
 318 add_menu_item(GtkWidget *menu, GtkWidget *menu_item, GCallback callback, gpointer callback_data)
 319 {
 320     gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);
 321     gtk_widget_show(menu_item);
 322     if (callback)
 323         g_signal_connect(G_OBJECT(menu_item), "activate", callback, callback_data);
 324     return menu_item;
 325 }
 326
 327
 328 static GtkWidget *
 329 radio_menu_item_new(GSList **group, const gchar *name)
 330 {
 331     GtkWidget *menu_item;
 332     menu_item = gtk_radio_menu_item_new_with_mnemonic(*group, name);
 333     *group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(menu_item));
 334     return menu_item;
 335 }
 336
 337
 338 static void
 339 create_menu(MathWindow *window)
 340 {
 341     GtkAccelGroup *accel_group;
 342     GtkWidget *menu, *menu_item;
 343     GSList *group = NULL;
 344
 345     accel_group = gtk_accel_group_new();
 346     gtk_window_add_accel_group(GTK_WINDOW(window), accel_group);
 347
 348     /* Calculator menu */
 349     #define CALCULATOR_MENU_LABEL _("_Calculator")
 350     /* Mode menu */
 351     #define MODE_MENU_LABEL _("_Mode")
 352     /* Help menu label */
 353     #define HELP_MENU_LABEL _("_Help")
 354     /* Basic menu label */
 355     #define MODE_BASIC_LABEL _("_Basic")
 356     /* Advanced menu label */
 357     #define MODE_ADVANCED_LABEL _("_Advanced")
 358     /* Financial menu label */
 359     #define MODE_FINANCIAL_LABEL _("_Financial")
 360     /* Programming menu label */
 361     #define MODE_PROGRAMMING_LABEL _("_Programming")
 362     /* Help>Contents menu label */
 363     #define HELP_CONTENTS_LABEL _("_Contents")
 364
 365     menu = add_menu(window->priv->menu_bar, CALCULATOR_MENU_LABEL);
 366     add_menu_item(menu, gtk_image_menu_item_new_from_stock(GTK_STOCK_COPY, accel_group), G_CALLBACK(copy_cb), window);
 367     add_menu_item(menu, gtk_image_menu_item_new_from_stock(GTK_STOCK_PASTE, accel_group), G_CALLBACK(paste_cb), window);
 368     menu_item = add_menu_item(menu, gtk_image_menu_item_new_from_stock(GTK_STOCK_UNDO, accel_group), G_CALLBACK(undo_cb), window);
 369     gtk_widget_add_accelerator(menu_item, "activate", accel_group, GDK_KEY_z, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
 370     menu_item = add_menu_item(menu, gtk_image_menu_item_new_from_stock(GTK_STOCK_REDO, accel_group), G_CALLBACK(redo_cb), window);
 371     gtk_widget_add_accelerator(menu_item, "activate", accel_group, GDK_KEY_z, GDK_CONTROL_MASK | GDK_SHIFT_MASK, GTK_ACCEL_VISIBLE);
 372     add_menu_item(menu, gtk_separator_menu_item_new(), NULL, NULL);
 373     add_menu_item(menu, gtk_image_menu_item_new_from_stock(GTK_STOCK_PREFERENCES, accel_group), G_CALLBACK(show_preferences_cb), window);
 374     add_menu_item(menu, gtk_separator_menu_item_new(), NULL, NULL);
 375     menu_item = add_menu_item(menu, gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, accel_group), G_CALLBACK(quit_cb), window);
 376     gtk_widget_add_accelerator(menu_item, "activate", accel_group, GDK_KEY_w, GDK_CONTROL_MASK, 0);
 377
 378     menu = add_menu(window->priv->menu_bar, MODE_MENU_LABEL);
 379     window->priv->mode_basic_menu_item = add_menu_item(menu, radio_menu_item_new(&group, MODE_BASIC_LABEL), G_CALLBACK(mode_changed_cb), window);
 380     g_object_set_data(G_OBJECT(window->priv->mode_basic_menu_item), "calcmode", GINT_TO_POINTER(BASIC));
 381     window->priv->mode_advanced_menu_item = add_menu_item(menu, radio_menu_item_new(&group, MODE_ADVANCED_LABEL), G_CALLBACK(mode_changed_cb), window);
 382     g_object_set_data(G_OBJECT(window->priv->mode_advanced_menu_item), "calcmode", GINT_TO_POINTER(ADVANCED));
 383     window->priv->mode_financial_menu_item = add_menu_item(menu, radio_menu_item_new(&group, MODE_FINANCIAL_LABEL), G_CALLBACK(mode_changed_cb), window);
 384     g_object_set_data(G_OBJECT(window->priv->mode_financial_menu_item), "calcmode", GINT_TO_POINTER(FINANCIAL));
 385     window->priv->mode_programming_menu_item = add_menu_item(menu, radio_menu_item_new(&group, MODE_PROGRAMMING_LABEL), G_CALLBACK(mode_changed_cb), window);
 386     g_object_set_data(G_OBJECT(window->priv->mode_programming_menu_item), "calcmode", GINT_TO_POINTER(PROGRAMMING));
 387
 388     menu = add_menu(window->priv->menu_bar, HELP_MENU_LABEL);
 389     menu_item = add_menu_item(menu, gtk_menu_item_new_with_mnemonic(HELP_CONTENTS_LABEL), G_CALLBACK(help_cb), window);
 390     gtk_widget_add_accelerator(menu_item, "activate", accel_group, GDK_KEY_F1, 0, GTK_ACCEL_VISIBLE);
 391     add_menu_item(menu, gtk_image_menu_item_new_from_stock(GTK_STOCK_ABOUT, accel_group), G_CALLBACK(about_cb), window);
 392 }
 393
 394
 395 static void
 396 create_gui(MathWindow *window)
 397 {
 398     GtkWidget *main_vbox, *vbox;
 399     GtkWidget *scrolled_window;
 400
 401     main_vbox = gtk_vbox_new(FALSE, 0);
 402     gtk_container_add(GTK_CONTAINER(window), main_vbox);
 403     gtk_widget_show(main_vbox);
 404
 405     window->priv->menu_bar = gtk_menu_bar_new();
 406     gtk_box_pack_start(GTK_BOX(main_vbox), window->priv->menu_bar, FALSE, FALSE, 0);
 407     gtk_widget_show(window->priv->menu_bar);
 408
 409     create_menu(window);
 410
 411     vbox = gtk_vbox_new(FALSE, 6);
 412     gtk_container_set_border_width(GTK_CONTAINER(vbox), 6);
 413     gtk_box_pack_start(GTK_BOX(main_vbox), vbox, TRUE, TRUE, 0);
 414     gtk_widget_show(vbox);
 415
 416     scrolled_window = gtk_scrolled_window_new(NULL, NULL);
 417     gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_NEVER);
 418     gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(scrolled_window), FALSE, FALSE, 0);
 419     g_signal_connect(gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(scrolled_window)), "changed", G_CALLBACK(scroll_changed_cb), window);
 420     g_signal_connect(gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(scrolled_window)), "value-changed", G_CALLBACK(scroll_value_changed_cb), window);
 421     window->priv->right_aligned = TRUE;
 422     gtk_widget_show(scrolled_window);
 423
 424     window->priv->display = math_display_new_with_equation(window->priv->equation);
 425     gtk_container_add(GTK_CONTAINER(scrolled_window), GTK_WIDGET(window->priv->display));
 426     gtk_widget_show(GTK_WIDGET(window->priv->display));
 427
 428     window->priv->buttons = math_buttons_new(window->priv->equation);
 429     g_signal_connect(window->priv->buttons, "notify::mode", G_CALLBACK(button_mode_changed_cb), window);
 430     button_mode_changed_cb(window->priv->buttons, NULL, window);
 431     gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(window->priv->buttons), TRUE, TRUE, 0);
 432     gtk_widget_show(GTK_WIDGET(window->priv->buttons));
 433 }
 434
 435
 436 static void
 437 math_window_set_property(GObject      *object,
 438                          guint         prop_id,
 439                          const GValue *value,
 440                          GParamSpec   *pspec)
 441 {
 442     MathWindow *self;
 443
 444     self = MATH_WINDOW(object);
 445
 446     switch (prop_id) {
 447     case PROP_EQUATION:
 448         self->priv->equation = g_value_get_object(value);
 449         create_gui(self);
 450         break;
 451     default:
 452         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 453         break;
 454     }
 455 }
 456
 457
 458 static void
 459 math_window_get_property(GObject    *object,
 460                          guint       prop_id,
 461                          GValue     *value,
 462                          GParamSpec *pspec)
 463 {
 464     MathWindow *self;
 465
 466     self = MATH_WINDOW(object);
 467
 468     switch (prop_id) {
 469     case PROP_EQUATION:
 470         g_value_set_object(value, self->priv->equation);
 471         break;
 472     default:
 473         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 474         break;
 475     }
 476 }
 477
 478
 479 static void
 480 math_window_class_init(MathWindowClass *klass)
 481 {
 482     GObjectClass *object_class = G_OBJECT_CLASS(klass);
 483
 484     object_class->get_property = math_window_get_property;
 485     object_class->set_property = math_window_set_property;
 486
 487     g_type_class_add_private(klass, sizeof(MathWindowPrivate));
 488
 489     g_object_class_install_property(object_class,
 490                                     PROP_EQUATION,
 491                                     g_param_spec_object("equation",
 492                                                         "equation",
 493                                                         "Equation being calculated",
 494                                                         math_equation_get_type(),
 495                                                         G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 496
 497     signals[QUIT] =
 498         g_signal_new("quit",
 499                      G_TYPE_FROM_CLASS (klass),
 500                      G_SIGNAL_RUN_LAST,
 501                      G_STRUCT_OFFSET (MathWindowClass, quit),
 502                      NULL, NULL,
 503                      g_cclosure_marshal_VOID__VOID,
 504                      G_TYPE_NONE, 0);
 505 }
 506
 507
 508 static void
 509 math_window_init(MathWindow *window)
 510 {
 511     window->priv = G_TYPE_INSTANCE_GET_PRIVATE(window, math_window_get_type(), MathWindowPrivate);
 512     gtk_window_set_title(GTK_WINDOW(window),
 513                          /* Title of main window */
 514                          _("Calculator"));
 515     gtk_window_set_icon_name(GTK_WINDOW(window), "accessories-calculator");
 516     gtk_window_set_role(GTK_WINDOW(window), "gcalctool");
 517     gtk_window_set_resizable(GTK_WINDOW(window), FALSE);
 518     g_signal_connect_after(G_OBJECT(window), "key-press-event", G_CALLBACK(key_press_cb), NULL);
 519     g_signal_connect(G_OBJECT(window), "delete-event", G_CALLBACK(delete_cb), NULL);
 520 }