helm/DEVEL/mathml_editor/test/guiGTK.c

   1 /*
   2  * Copyright (C) 2000, Luca Padovani <luca.padovani@cs.unibo.it>.
   3  *
   4  * This file is part of GtkMathView, a Gtk widget for MathML.
   5  *
   6  * GtkMathView is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version 2
   9  * of the License, or (at your option) any later version.
  10  *
  11  * GtkMathView is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with GtkMathView; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19  *
  20  * For details, see the GtkMathView World-Wide-Web page,
  21  * http://cs.unibo.it/~lpadovan/mml-widget, or send a mail to
  22  * <luca.padovani@cs.unibo.it>
  23  */
  24
  25 #include <config.h>
  26 #include <stdio.h>
  27 #include <gtk/gtk.h>
  28 #include <gdk/gdkkeysyms.h>
  29
  30 #include <gtkmathview/gtkmathview.h>
  31 #include "guiGTK.h"
  32
  33 #define XLINK_NS_URI "http://www.w3.org/1999/xlink"
  34
  35 static GtkWidget* window;
  36 static GtkWidget* main_area;
  37 static GtkWidget* scrolled_area;
  38 static GtkMenuItem* anti_aliasing_item;
  39 static GtkMenuItem* transparency_item;
  40
  41 static gpointer context = NULL;
  42 static gchar* doc_name = NULL;
  43 static GdomeElement* first_selected = NULL;
  44 static GdomeElement* root_selected = NULL;
  45
  46 static void create_widget_set(gpointer);
  47 static GtkWidget* get_main_menu(void);
  48 static void file_open(GtkWidget*, gpointer);
  49 static void file_re_open(GtkWidget*, gpointer);
  50 static void file_close(GtkWidget*, gpointer);
  51 static void file_output_tex(GtkWidget*, gpointer);
  52 static void options_font_manager(GtkWidget*, FontManagerId);
  53 static void options_set_font_size(GtkWidget*, gpointer);
  54 static void options_change_font_size(GtkWidget*, gboolean);
  55 static void options_verbosity(GtkWidget*, guint);
  56 static void options_anti_aliasing(GtkWidget*, gpointer);
  57 static void options_transparency(GtkWidget*, gpointer);
  58 static void edit_delete_selection(GtkWidget*, gpointer);
  59 static void edit_select_parent(GtkWidget*, gpointer);
  60 static void edit_reset_selection(GtkWidget*, gpointer);
  61 static void edit_reset(GtkWidget*, gpointer);
  62 static void edit_insert(GtkWidget*, gpointer);
  63 static void help_about(GtkWidget*, gpointer);
  64
  65 static GtkItemFactoryEntry menu_items[] = {
  66   { "/_File",                          NULL,         NULL,          0, "<Branch>" },
  67   { "/File/_Open...",                  "<control>O", file_open,     0, NULL },
  68   { "/File/_Reopen",                   NULL,         file_re_open,  0, NULL },
  69   { "/File/_Close",                    "<control>W", file_close,    0, NULL },
  70   { "/File/Output _TeX",               NULL,         file_output_tex, 0, NULL },
  71   { "/File/sep1",                      NULL,         NULL,          0, "<Separator>" },
  72   { "/File/_Quit",                     "<control>Q", gtk_main_quit, 0, NULL },
  73
  74   { "/_Edit",                          NULL, NULL,                  0,  "<Branch>" },
  75   { "/Edit/Reset Selection",           NULL, edit_reset_selection,  0, NULL },
  76   { "/Edit/Delete Selection",          NULL, edit_delete_selection, 0, NULL },
  77   { "/Edit/Select Parent",             NULL, edit_select_parent,    0, NULL },
  78   { "/Edit/sep1",                      NULL,         NULL,          0, "<Separator>" },
  79   { "/Edit/_Reset",                    NULL, edit_reset,            0, NULL },
  80   { "/Edit/Insert...",                 "<control>I", edit_insert,   0, NULL },
  81
  82   { "/_Options",                       NULL, NULL,                  0,  "<Branch>" },
  83   { "/Options/Default _Font Size",     NULL, NULL,                  0,  "<Branch>" },
  84   { "/Options/Default Font Size/Set...", NULL, options_set_font_size, 0,  NULL },
  85   { "/Options/Default Font Size/sep1", NULL, NULL,                  0,  "<Separator>" },
  86   { "/Options/Default Font Size/Larger", NULL, options_change_font_size, TRUE, NULL },
  87   { "/Options/Default Font Size/Smaller", NULL, options_change_font_size, FALSE, NULL },
  88   { "/Options/Font Manager",           NULL, NULL,                  0,  "<Branch>" },
  89   { "/Options/Font Manager/_GTK",      NULL, options_font_manager,  FONT_MANAGER_GTK, "<RadioItem>" },
  90   { "/Options/Font Manager/_Type 1",   NULL, options_font_manager,  FONT_MANAGER_T1, "/Options/Font Manager/GTK" },
  91   { "/Options/Verbosity",              NULL, NULL,                  0,  "<Branch>" },
  92   { "/Options/Verbosity/_Errors",      NULL, options_verbosity,     0,  "<RadioItem>" },
  93   { "/Options/Verbosity/_Warnings",    NULL, options_verbosity,     1,  "/Options/Verbosity/Errors" },
  94   { "/Options/Verbosity/_Info",        NULL, options_verbosity,     2,  "/Options/Verbosity/Errors" },
  95   { "/Options/Verbosity/_Debug",       NULL, options_verbosity,     3,  "/Options/Verbosity/Errors" },
  96   { "/Options/sep1",                   NULL, NULL,                  0,  "<Separator>" },
  97   { "/Options/_Anti Aliasing",         NULL, options_anti_aliasing, 0,  "<ToggleItem>" },
  98   { "/Options/_Transparency",          NULL, options_transparency,  0,  "<ToggleItem>" },
  99
 100   { "/_Help" ,        NULL,         NULL,          0, "<LastBranch>" },
 101   { "/Help/About...", NULL,         help_about,    0, NULL }
 102 };
 103
 104 static void
 105 quick_message(const char* msg)
 106 {
 107   GtkWidget* dialog;
 108   GtkWidget* label;
 109   GtkWidget* okay_button;
 110
 111   /* Create the widgets */
 112
 113   dialog = gtk_dialog_new();
 114   label = gtk_label_new (msg);
 115   okay_button = gtk_button_new_with_label("OK");
 116
 117   gtk_widget_set_usize(dialog, 300, 100);
 118
 119   /* Ensure that the dialog box is destroyed when the user clicks ok. */
 120
 121   gtk_signal_connect_object (GTK_OBJECT (okay_button), "clicked",
 122                              GTK_SIGNAL_FUNC (gtk_widget_destroy), dialog);
 123   gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->action_area),
 124                      okay_button);
 125
 126   /* Add the label, and show everything we've added to the dialog. */
 127
 128   gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox), label);
 129   gtk_widget_show_all (dialog);
 130 }
 131
 132 static void
 133 load_error_msg(const char* name)
 134 {
 135   char* msg = g_strdup_printf("Could not load\n`%s'", name);
 136   quick_message(msg);
 137   g_free(msg);
 138 }
 139
 140 void
 141 GUI_init(int* argc, char*** argv, char* title, guint width, guint height, gpointer c)
 142 {
 143   gtk_init(argc, argv);
 144
 145   window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 146   gtk_window_set_title(GTK_WINDOW(window), title);
 147   gtk_window_set_default_size(GTK_WINDOW(window), width, height);
 148   gtk_signal_connect(GTK_OBJECT(window), "delete_event", (GtkSignalFunc) gtk_main_quit, NULL);
 149   create_widget_set(context);
 150
 151   gtk_widget_show(window);
 152
 153   context = c;
 154   /*edit_timeout_id = gtk_timeout_add(400, edit_timeout, context);*/
 155 }
 156
 157 void
 158 GUI_uninit()
 159 {
 160   GdomeException exc = 0;
 161
 162   if (first_selected != NULL)
 163     {
 164       gdome_el_unref(first_selected, &exc);
 165       g_assert(exc == 0);
 166       first_selected = NULL;
 167     }
 168
 169   if (root_selected != NULL)
 170     {
 171       gdome_el_unref(root_selected, &exc);
 172       g_assert(exc == 0);
 173       root_selected = NULL;
 174     }
 175
 176   context = NULL;
 177 }
 178
 179 int
 180 GUI_load_document(GdomeDocument* doc)
 181 {
 182   GtkMathView* math_view;
 183
 184   g_return_val_if_fail(doc != NULL, -1);
 185   g_return_val_if_fail(main_area != NULL, -1);
 186   g_return_val_if_fail(GTK_IS_MATH_VIEW(main_area), -1);
 187
 188   math_view = GTK_MATH_VIEW(main_area);
 189
 190   if (!gtk_math_view_load_doc(math_view, doc)) return -1;
 191
 192   return 0;
 193 }
 194
 195 void
 196 GUI_freeze()
 197 {
 198   gtk_math_view_freeze(GTK_MATH_VIEW(main_area));
 199 }
 200
 201 void
 202 GUI_thaw()
 203 {
 204   gtk_math_view_thaw(GTK_MATH_VIEW(main_area));
 205 }
 206
 207 void
 208 GUI_unload_document()
 209 {
 210   GtkMathView* math_view;
 211
 212   g_return_if_fail(main_area != NULL);
 213   g_return_if_fail(GTK_IS_MATH_VIEW(main_area));
 214
 215   math_view = GTK_MATH_VIEW(main_area);
 216
 217   gtk_math_view_unload(math_view);
 218
 219   if (doc_name != NULL) g_free(doc_name);
 220   doc_name = NULL;
 221 }
 222
 223 void
 224 GUI_run()
 225 {
 226   gtk_main();
 227 }
 228
 229 void
 230 GUI_set_font_manager(FontManagerId id)
 231 {
 232   gboolean t1;
 233   GtkMathView* math_view;
 234
 235   g_return_if_fail(id != FONT_MANAGER_UNKNOWN);
 236   g_return_if_fail(main_area != NULL);
 237   g_return_if_fail(GTK_IS_MATH_VIEW(main_area));
 238
 239   t1 = id == FONT_MANAGER_T1;
 240
 241   math_view = GTK_MATH_VIEW(main_area);
 242
 243   gtk_math_view_freeze(math_view);
 244
 245   if (id != gtk_math_view_get_font_manager_type(math_view))
 246     gtk_math_view_set_font_manager_type(math_view, id);
 247
 248   gtk_widget_set_sensitive(anti_aliasing_item, t1);
 249   gtk_widget_set_sensitive(transparency_item, t1);
 250
 251   if (t1)
 252     {
 253       gtk_math_view_set_anti_aliasing(math_view, GTK_CHECK_MENU_ITEM(anti_aliasing_item)->active);
 254       gtk_math_view_set_transparency(math_view, GTK_CHECK_MENU_ITEM(transparency_item)->active);
 255     }
 256
 257   gtk_math_view_thaw(math_view);
 258 }
 259
 260 static void
 261 store_filename(GtkFileSelection* selector, GtkWidget* user_data)
 262 {
 263   gchar* selected_filename = gtk_file_selection_get_filename (GTK_FILE_SELECTION(user_data));
 264   if (selected_filename != NULL)
 265     GUI_load_document(selected_filename);
 266 }
 267
 268 static void
 269 file_close(GtkWidget* widget, gpointer data)
 270 {
 271   GUI_unload_document();
 272 }
 273
 274 static void
 275 file_re_open(GtkWidget* widget, gpointer data)
 276 {
 277   if (doc_name != NULL) {
 278     GUI_load_document(doc_name);
 279   }
 280 }
 281
 282 static void
 283 file_open(GtkWidget* widget, gpointer data)
 284 {
 285   GtkWidget* fs = gtk_file_selection_new("Open File");
 286
 287   gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION(fs)->ok_button),
 288                       "clicked", GTK_SIGNAL_FUNC (store_filename), (gpointer) fs);
 289
 290   /* Ensure that the dialog box is destroyed when the user clicks a button. */
 291
 292   gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION(fs)->ok_button),
 293                              "clicked", GTK_SIGNAL_FUNC (gtk_widget_destroy),
 294                              (gpointer) fs);
 295
 296   gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION(fs)->cancel_button),
 297                              "clicked", GTK_SIGNAL_FUNC (gtk_widget_destroy),
 298                              (gpointer) fs);
 299
 300   /* Display that dialog */
 301
 302   gtk_widget_show (fs);
 303 }
 304
 305 static void
 306 file_output_tex(GtkWidget* widget, gpointer data)
 307 {
 308   g_assert(context != NULL);
 309   edit_output_tex(context);
 310 }
 311
 312 static void
 313 options_font_manager(GtkWidget* widget, FontManagerId id)
 314 {
 315   g_return_if_fail(id != FONT_MANAGER_UNKNOWN);
 316   GUI_set_font_manager(id);
 317 }
 318
 319 static void
 320 options_anti_aliasing(GtkWidget* widget, gpointer data)
 321 {
 322   gboolean aa = gtk_math_view_get_anti_aliasing(GTK_MATH_VIEW(main_area));
 323   gtk_math_view_set_anti_aliasing(GTK_MATH_VIEW(main_area), !aa);
 324 }
 325
 326 static void
 327 options_transparency(GtkWidget* widget, gpointer data)
 328 {
 329   gboolean t = gtk_math_view_get_transparency(GTK_MATH_VIEW(main_area));
 330   gtk_math_view_set_transparency(GTK_MATH_VIEW(main_area), !t);
 331 }
 332
 333 static void
 334 options_verbosity(GtkWidget* widget, guint level)
 335 {
 336   gtk_math_view_set_log_verbosity(GTK_MATH_VIEW(main_area), level);
 337 }
 338
 339 static void
 340 edit_delete_selection(GtkWidget* widget, gpointer data)
 341 {
 342   if (root_selected != NULL)
 343     {
 344       GdomeException exc;
 345       gtk_math_view_freeze(GTK_MATH_VIEW(main_area));
 346       printf("about to remove element %p\n", root_selected);
 347       delete_element(root_selected);
 348       gdome_el_unref(root_selected, &exc);
 349       g_assert(exc == 0);
 350       root_selected = NULL;
 351       gtk_math_view_thaw(GTK_MATH_VIEW(main_area));
 352     }
 353 }
 354
 355 static void
 356 edit_select_parent(GtkWidget* widget, gpointer data)
 357 {
 358   if (root_selected != NULL)
 359     {
 360       GdomeException exc = 0;
 361       GdomeElement* parent = gdome_n_parentNode(root_selected, &exc);
 362       g_assert(exc == 0);
 363       gdome_el_unref(root_selected, &exc);
 364       g_assert(exc == 0);
 365       root_selected = parent;
 366       /* gtk_math_view_set_selection(GTK_MATH_VIEW(main_area), root_selected); */
 367     }
 368 }
 369
 370 static void
 371 edit_reset_selection(GtkWidget* widget, gpointer data)
 372 {
 373   if (root_selected != NULL)
 374     {
 375       GdomeException exc = 0;
 376       /* gtk_math_view_reset_selection(GTK_MATH_VIEW(main_area), root_selected); */
 377       gdome_el_unref(root_selected, &exc);
 378       g_assert(exc == 0);
 379       root_selected = NULL;
 380     }
 381 }
 382
 383 static void
 384 edit_reset(GtkWidget* widget, gpointer data)
 385 {
 386   g_assert(context != NULL);
 387   edit_reset_tex(context);
 388 }
 389
 390 static void
 391 insert_tex(GtkWidget* widget, GtkEntry* entry)
 392 {
 393   gchar* text;
 394   g_return_if_fail(entry != NULL);
 395
 396   text = gtk_editable_get_chars(GTK_EDITABLE(entry), 0, -1);
 397   edit_push_string(context, text);
 398   g_free(text);
 399 }
 400
 401 static void
 402 edit_insert(GtkWidget* widget, gpointer data)
 403 {
 404   GtkWidget* dialog;
 405   GtkWidget* entry;
 406   GtkWidget* ok;
 407   GtkWidget* cancel;
 408
 409   dialog = gtk_dialog_new();
 410   entry = gtk_entry_new();
 411   ok = gtk_button_new_with_label("OK");
 412   cancel = gtk_button_new_with_label("Cancel");
 413
 414   gtk_signal_connect (GTK_OBJECT (ok), "clicked",
 415                       GTK_SIGNAL_FUNC (insert_tex), (gpointer) entry);
 416
 417   gtk_signal_connect_object (GTK_OBJECT (ok), "clicked",
 418                              GTK_SIGNAL_FUNC (gtk_widget_destroy), (gpointer) dialog);
 419
 420   gtk_signal_connect_object (GTK_OBJECT (ok), "clicked",
 421                              GTK_SIGNAL_FUNC (gtk_widget_destroy), (gpointer) dialog);
 422
 423   gtk_signal_connect_object (GTK_OBJECT (cancel), "clicked",
 424                              GTK_SIGNAL_FUNC (gtk_widget_destroy), (gpointer) dialog);
 425
 426   gtk_container_set_border_width (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox), 5);
 427
 428   gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox), entry);
 429   gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->action_area), ok);
 430   gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->action_area), cancel);
 431
 432   gtk_widget_show_all (dialog);
 433 }
 434
 435 static void
 436 help_about(GtkWidget* widget, gpointer data)
 437 {
 438   GtkWidget* dialog;
 439   GtkWidget* label;
 440   GtkWidget* ok;
 441
 442   dialog = gtk_dialog_new();
 443   label = gtk_label_new("\n    MathML Editor    \n    Copyright (C) 2003 Luca Padovani    \n");
 444   ok = gtk_button_new_with_label("Close");
 445
 446   gtk_signal_connect_object (GTK_OBJECT (ok), "clicked",
 447                              GTK_SIGNAL_FUNC (gtk_widget_destroy), (gpointer) dialog);
 448   gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->action_area),
 449                      ok);
 450
 451   gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox), label);
 452
 453   gtk_widget_show_all (dialog);
 454 }
 455
 456 static void
 457 change_default_font_size(GtkWidget* widget, GtkSpinButton* spin)
 458 {
 459   g_return_if_fail(spin != NULL);
 460   gtk_math_view_set_font_size( GTK_MATH_VIEW(main_area), gtk_spin_button_get_value_as_int(spin));
 461 }
 462
 463 static void
 464 options_change_font_size(GtkWidget* widget, gboolean larger)
 465 {
 466   gfloat size = gtk_math_view_get_font_size (GTK_MATH_VIEW(main_area));
 467   if (larger) size = size / 0.71;
 468   else size = size * 0.71;
 469   if (size < 1) size = 1;
 470   gtk_math_view_set_font_size (GTK_MATH_VIEW(main_area), (gint) size + 0.5);
 471 }
 472
 473 static void
 474 options_set_font_size(GtkWidget* widget, gpointer data)
 475 {
 476   GtkWidget* dialog;
 477   GtkWidget* label;
 478   GtkWidget* ok;
 479   GtkWidget* cancel;
 480   GtkWidget* spin;
 481   GtkObject* adj;
 482
 483   dialog = gtk_dialog_new();
 484   label = gtk_label_new("Default font size:");
 485   ok = gtk_button_new_with_label("OK");
 486   cancel = gtk_button_new_with_label("Cancel");
 487
 488   adj = gtk_adjustment_new (gtk_math_view_get_font_size (GTK_MATH_VIEW(main_area)), 1, 200, 1, 1, 1);
 489   spin = gtk_spin_button_new (GTK_ADJUSTMENT(adj), 1, 0);
 490   gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spin), TRUE);
 491
 492   gtk_signal_connect (GTK_OBJECT (ok), "clicked",
 493                       GTK_SIGNAL_FUNC (change_default_font_size), (gpointer) spin);
 494
 495   gtk_signal_connect_object (GTK_OBJECT (ok), "clicked",
 496                              GTK_SIGNAL_FUNC (gtk_widget_destroy), (gpointer) dialog);
 497
 498   gtk_signal_connect_object (GTK_OBJECT (ok), "clicked",
 499                              GTK_SIGNAL_FUNC (gtk_widget_destroy), (gpointer) dialog);
 500
 501   gtk_signal_connect_object (GTK_OBJECT (cancel), "clicked",
 502                              GTK_SIGNAL_FUNC (gtk_widget_destroy), (gpointer) dialog);
 503
 504   gtk_container_set_border_width (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox), 5);
 505
 506   gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->action_area), ok);
 507   gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->action_area), cancel);
 508   gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox), label);
 509   gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox), spin);
 510
 511   gtk_widget_show_all (dialog);
 512 }
 513
 514 static void
 515 select_begin(GtkMathView* math_view, GdomeElement* first, gint state)
 516 {
 517   GdomeException exc = 0;
 518
 519   g_return_if_fail(math_view != NULL);
 520   g_return_if_fail(GTK_IS_MATH_VIEW(math_view));
 521   g_return_if_fail(first != NULL);
 522
 523   gtk_math_view_freeze(math_view);
 524
 525   if (root_selected != NULL)
 526     {
 527       gtk_math_view_unselect(math_view, root_selected);
 528       gdome_el_unref(root_selected, &exc);
 529       g_assert(exc == 0);
 530     }
 531
 532   root_selected = first_selected = find_element_with_ref(first);
 533
 534   if (root_selected != NULL)
 535     {
 536       gtk_math_view_select(math_view, root_selected);
 537       gdome_el_ref(root_selected, &exc);
 538       g_assert(exc == 0);
 539     }
 540
 541   gtk_math_view_thaw(math_view);
 542 }
 543
 544 static void
 545 select_over(GtkMathView* math_view, GdomeElement* elem, gint state)
 546 {
 547   GdomeElement* new_selected = NULL;
 548   GdomeException exc = 0;
 549
 550   g_return_if_fail(math_view != NULL);
 551   g_return_if_fail(GTK_IS_MATH_VIEW(math_view));
 552   g_return_if_fail(elem != NULL);
 553
 554   if (first_selected == NULL || elem == NULL)
 555     new_selected = NULL;
 556   else
 557     new_selected = find_common_ancestor_with_ref(first_selected, elem);
 558
 559   if (new_selected != root_selected)
 560     {
 561       gtk_math_view_freeze(math_view);
 562       if (root_selected != NULL)
 563         {
 564           gtk_math_view_unselect(math_view, root_selected);
 565           gdome_el_unref(root_selected, &exc);
 566           g_assert(exc == 0);
 567         }
 568       root_selected = new_selected;
 569       if (root_selected != NULL)
 570         gtk_math_view_select(math_view, root_selected);
 571       gtk_math_view_thaw(math_view);
 572     }
 573   else if (new_selected != NULL)
 574     {
 575       gdome_el_unref(new_selected, &exc);
 576       g_assert(exc == 0);
 577     }
 578
 579 }
 580
 581 static gboolean
 582 key_press_event(gpointer c,
 583                 GdkEventKey* event,
 584                 GtkWidget* widget)
 585 {
 586   g_return_val_if_fail(widget != NULL, FALSE);
 587   g_return_val_if_fail(event != NULL, FALSE);
 588   g_return_val_if_fail(context != NULL, FALSE);
 589
 590   if (event->type != GDK_KEY_PRESS) return FALSE;
 591
 592   switch (event->keyval)
 593     {
 594     case GDK_BackSpace:
 595       edit_drop(context, event->state & GDK_MOD1_MASK);
 596       break;
 597     default:
 598       if ((event->state & (~GDK_SHIFT_MASK)) == 0 && event->keyval < 0x80)
 599         edit_push_char(context, event->keyval);
 600       return FALSE;
 601     }
 602
 603   return TRUE;
 604 }
 605
 606 static void
 607 create_widget_set(gpointer context)
 608 {
 609   GtkWidget* main_vbox;
 610   GtkWidget* menu_bar;
 611
 612   main_vbox = gtk_vbox_new(FALSE, 1);
 613   gtk_container_border_width(GTK_CONTAINER(main_vbox), 1);
 614   gtk_container_add(GTK_CONTAINER(window), main_vbox);
 615   gtk_widget_show(main_vbox);
 616
 617   menu_bar = get_main_menu();
 618   gtk_box_pack_start(GTK_BOX(main_vbox), menu_bar, FALSE, TRUE, 0);
 619   gtk_widget_show(menu_bar);
 620
 621   main_area = gtk_math_view_new(NULL, NULL);
 622   gtk_widget_show(main_area);
 623
 624   //gtk_math_view_set_log_verbosity(GTK_MATH_VIEW(main_area), 3);
 625
 626   gtk_signal_connect_object (GTK_OBJECT (main_area),
 627                              "select_begin", GTK_SIGNAL_FUNC (select_begin),
 628                              (gpointer) main_area);
 629
 630   gtk_signal_connect_object (GTK_OBJECT (main_area),
 631                              "select_over", GTK_SIGNAL_FUNC (select_over),
 632                              (gpointer) main_area);
 633
 634   gtk_signal_connect_object (GTK_OBJECT(window),
 635                              "key_press_event", GTK_SIGNAL_FUNC(key_press_event),
 636                              context);
 637
 638   gtk_widget_add_events(GTK_WIDGET(main_area), GDK_KEY_PRESS_MASK);
 639
 640   scrolled_area = gtk_scrolled_window_new(NULL, NULL);
 641   gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_area),
 642                                  GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
 643
 644   gtk_widget_show(scrolled_area);
 645   gtk_container_add(GTK_CONTAINER(scrolled_area), main_area);
 646   gtk_box_pack_start(GTK_BOX(main_vbox), scrolled_area, TRUE, TRUE, 0);
 647
 648   gtk_widget_show(main_vbox);
 649
 650   if (gtk_math_view_get_anti_aliasing(GTK_MATH_VIEW(main_area)))
 651     gtk_menu_item_activate(anti_aliasing_item);
 652 }
 653
 654 GtkWidget*
 655 get_main_menu()
 656 {
 657   GtkItemFactory* item_factory;
 658   GtkAccelGroup* accel_group;
 659   GtkWidget* menu_item;
 660
 661   gint nmenu_items = sizeof(menu_items) / sizeof(menu_items[0]);
 662
 663   accel_group = gtk_accel_group_new();
 664
 665   item_factory = gtk_item_factory_new(GTK_TYPE_MENU_BAR, "<main>", accel_group);
 666
 667   gtk_item_factory_create_items(item_factory, nmenu_items, menu_items, NULL);
 668
 669   gtk_window_add_accel_group(GTK_WINDOW(window), accel_group);
 670
 671   menu_item = gtk_item_factory_get_widget(item_factory, "/Options/Anti Aliasing");
 672   anti_aliasing_item = GTK_MENU_ITEM(menu_item);
 673
 674   menu_item = gtk_item_factory_get_widget(item_factory, "/Options/Transparency");
 675   transparency_item = GTK_MENU_ITEM(menu_item);
 676
 677   return gtk_item_factory_get_widget(item_factory, "<main>");
 678 }