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