helm/DEVEL/mathml_editor/test/guiGTK.c

   1
   2 #include <stdio.h>
   3 #include <gtk/gtk.h>
   4 #include <gdk/gdkkeysyms.h>
   5
   6 #include "gtkmathview.h"
   7 #include "guiGTK.h"
   8
   9 #define XLINK_NS_URI "http://www.w3.org/1999/xlink"
  10
  11 static GtkWidget* window;
  12 static GtkWidget* main_area;
  13 static GtkWidget* scrolled_area;
  14 static GtkWidget* status_bar;
  15 static GtkMenuItem* anti_aliasing_item;
  16 static GtkMenuItem* transparency_item;
  17 static GtkMenuItem* font_size_item;
  18 static GdkCursor* normal_cursor;
  19 static GdkCursor* link_cursor;
  20
  21 static gchar* doc_name = NULL;
  22 static GdomeElement* root_selected = NULL;
  23 static GdomeElement* first_selected = NULL;
  24 static GdomeElement* last_selected = NULL;
  25 static GdomeElement* cursor = NULL;
  26 static gboolean selecting = FALSE;
  27 static gboolean button_pressed = FALSE;
  28
  29 static guint statusbar_context;
  30
  31 static guint         edit_timeout_id;
  32 static GdomeElement* cursor_ptr = NULL;
  33 static gboolean      cursor_active = FALSE;
  34
  35 static void create_widget_set(gpointer);
  36 static GtkWidget* get_main_menu(void);
  37 static void options_selection_mode(GtkWidget*, guint);
  38 static void options_font_size(GtkWidget*, guint);
  39 static void options_verbosity(GtkWidget*, guint);
  40 static void options_anti_aliasing(GtkWidget*, gpointer);
  41 static void options_transparency(GtkWidget*, gpointer);
  42 static void edit_delete_selection(GtkWidget*, gpointer);
  43 static void edit_select_parent(GtkWidget*, gpointer);
  44 static void help_about(GtkWidget*, gpointer);
  45
  46 extern int edit_timeout(gpointer);
  47 extern void push_char(gpointer, gchar);
  48
  49 static GtkItemFactoryEntry menu_items[] = {
  50   { "/_File",                          NULL,         NULL,          0, "<Branch>" },
  51   { "/File/_Quit",                     "<control>Q", gtk_main_quit, 0, NULL },
  52
  53   { "/_Edit",                          NULL, NULL,                  0,  "<Branch>" },
  54   { "/Edit/Delete Selection",          NULL, edit_delete_selection, 0,  NULL },
  55   { "/Edit/Select Parent",             NULL, edit_select_parent,    0,  NULL },
  56
  57   { "/_Options",                       NULL, NULL,                  0,  "<Branch>" },
  58   { "/Options/_Selection Mode",        NULL, NULL,                  0,  "<Branch>" },
  59   { "/Options/Selection Mode/_Structure", NULL, options_selection_mode, 0, "<RadioItem>" },
  60   { "/Options/Selection Mode/_Linear",  NULL, options_selection_mode, 1, "/Options/Selection Mode/Structure" },
  61   { "/Options/Default _Font Size",     NULL, NULL,                  0,  "<Branch>" },
  62   { "/Options/Default Font Size/8pt",  NULL, options_font_size,     8,  "<RadioItem>" },
  63   { "/Options/Default Font Size/10pt", NULL, options_font_size,     10, "/Options/Default Font Size/8pt" },
  64   { "/Options/Default Font Size/12pt", NULL, options_font_size,     12, "/Options/Default Font Size/8pt" },
  65   { "/Options/Default Font Size/14pt", NULL, options_font_size,     14, "/Options/Default Font Size/8pt" },
  66   { "/Options/Default Font Size/18pt", NULL, options_font_size,     18, "/Options/Default Font Size/8pt" },
  67   { "/Options/Default Font Size/24pt", NULL, options_font_size,     24, "/Options/Default Font Size/8pt" },
  68   { "/Options/Default Font Size/48pt", NULL, options_font_size,     48, "/Options/Default Font Size/8pt" },
  69   { "/Options/Default Font Size/72pt", NULL, options_font_size,     72, "/Options/Default Font Size/8pt" },
  70   { "/Options/Verbosity",              NULL, NULL,                  0,  "<Branch>" },
  71   { "/Options/Verbosity/_Errors",      NULL, options_verbosity,     0,  "<RadioItem>" },
  72   { "/Options/Verbosity/_Warnings",    NULL, options_verbosity,     1,  "/Options/Verbosity/Errors" },
  73   { "/Options/Verbosity/_Info",        NULL, options_verbosity,     2,  "/Options/Verbosity/Errors" },
  74   { "/Options/Verbosity/_Debug",       NULL, options_verbosity,     3,  "/Options/Verbosity/Errors" },
  75   { "/Options/sep1",                   NULL, NULL,                  0,  "<Separator>" },
  76   { "/Options/_Anti Aliasing",         NULL, options_anti_aliasing, 0,  "<ToggleItem>" },
  77   { "/Options/_Transparency",          NULL, options_transparency,  0,  "<ToggleItem>" },
  78
  79   { "/_Help" ,        NULL,         NULL,          0, "<LastBranch>" },
  80   { "/Help/About...", NULL,         help_about,    0, NULL }
  81 };
  82
  83 static void
  84 quick_message(const char* msg)
  85 {
  86   GtkWidget* dialog;
  87   GtkWidget* label;
  88   GtkWidget* okay_button;
  89
  90   /* Create the widgets */
  91
  92   dialog = gtk_dialog_new();
  93   label = gtk_label_new (msg);
  94   okay_button = gtk_button_new_with_label("OK");
  95
  96   gtk_widget_set_usize(dialog, 300, 100);
  97
  98   /* Ensure that the dialog box is destroyed when the user clicks ok. */
  99
 100   gtk_signal_connect_object (GTK_OBJECT (okay_button), "clicked",
 101                              GTK_SIGNAL_FUNC (gtk_widget_destroy), dialog);
 102   gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->action_area),
 103                      okay_button);
 104
 105   /* Add the label, and show everything we've added to the dialog. */
 106
 107   gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox), label);
 108   gtk_widget_show_all (dialog);
 109 }
 110
 111 static void
 112 load_error_msg(const char* name)
 113 {
 114   char* msg = g_strdup_printf("Could not load\n`%s'", name);
 115   quick_message(msg);
 116   g_free(msg);
 117 }
 118
 119 static void
 120 cursor_off()
 121 {
 122   if (cursor_active)
 123     {
 124       cursor_active = FALSE;
 125       if (cursor_ptr != NULL &&
 126           gtk_math_view_is_selected(main_area, cursor_ptr))
 127         gtk_math_view_reset_selection(main_area, cursor_ptr);
 128     }
 129 }
 130
 131 static void
 132 cursor_on()
 133 {
 134   if (!cursor_active)
 135     {
 136       cursor_active = FALSE;
 137       if (cursor_ptr != NULL &&
 138           !gtk_math_view_is_selected(main_area, cursor_ptr))
 139         gtk_math_view_set_selection(main_area, cursor_ptr);
 140       cursor_active = TRUE;
 141     }
 142 }
 143
 144 void
 145 GUI_init(int* argc, char*** argv, char* title, guint width, guint height, gpointer context)
 146 {
 147   gtk_init(argc, argv);
 148
 149   window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 150   gtk_window_set_title(GTK_WINDOW(window), title);
 151   gtk_window_set_default_size(GTK_WINDOW(window), width, height);
 152   gtk_signal_connect(GTK_OBJECT(window), "delete_event", (GtkSignalFunc) gtk_main_quit, NULL);
 153   create_widget_set(context);
 154
 155   gtk_widget_show(window);
 156
 157   normal_cursor = gdk_cursor_new(GDK_TOP_LEFT_ARROW);
 158   link_cursor = gdk_cursor_new(GDK_HAND2);
 159
 160   /*edit_timeout_id = gtk_timeout_add(400, edit_timeout, context);*/
 161 }
 162
 163 void
 164 GUI_uninit()
 165 {
 166   gtk_timeout_remove(edit_timeout_id);
 167 }
 168
 169 int
 170 GUI_load_document(GdomeDocument* doc)
 171 {
 172   GtkMathView* math_view;
 173
 174   g_return_val_if_fail(doc != NULL, -1);
 175   g_return_val_if_fail(main_area != NULL, -1);
 176   g_return_val_if_fail(GTK_IS_MATH_VIEW(main_area), -1);
 177
 178   math_view = GTK_MATH_VIEW(main_area);
 179
 180   if (!gtk_math_view_load_doc(math_view, doc)) return -1;
 181
 182   return 0;
 183 }
 184
 185 int
 186 GUI_load_uri(const char* uri)
 187 {
 188   GtkMathView* math_view;
 189
 190   g_return_val_if_fail(uri != NULL, -1);
 191   g_return_val_if_fail(main_area != NULL, -1);
 192   g_return_val_if_fail(GTK_IS_MATH_VIEW(main_area), -1);
 193
 194   math_view = GTK_MATH_VIEW(main_area);
 195
 196   if (!gtk_math_view_load_uri(math_view, uri)) return -1;
 197
 198   return 0;
 199 }
 200
 201 void
 202 GUI_freeze()
 203 {
 204   gtk_math_view_freeze(GTK_MATH_VIEW(main_area));
 205 }
 206
 207 void
 208 GUI_thaw()
 209 {
 210   gtk_math_view_thaw(GTK_MATH_VIEW(main_area));
 211 }
 212
 213 void
 214 GUI_unload_document()
 215 {
 216   GtkMathView* math_view;
 217
 218   g_return_if_fail(main_area != NULL);
 219   g_return_if_fail(GTK_IS_MATH_VIEW(main_area));
 220
 221   math_view = GTK_MATH_VIEW(main_area);
 222
 223   gtk_math_view_unload(math_view);
 224
 225   if (doc_name != NULL) g_free(doc_name);
 226   doc_name = NULL;
 227
 228   gtk_statusbar_pop(GTK_STATUSBAR(status_bar), statusbar_context);
 229   gtk_statusbar_push(GTK_STATUSBAR(status_bar), statusbar_context, "");
 230 }
 231
 232 void
 233 GUI_run()
 234 {
 235   gtk_main();
 236 }
 237
 238 static void
 239 options_selection_mode(GtkWidget* widget, guint mode)
 240 {
 241 }
 242
 243 static void
 244 options_font_size(GtkWidget* widget, guint size)
 245 {
 246   GtkMathView* math_view;
 247
 248   g_return_if_fail(main_area != NULL);
 249   g_return_if_fail(GTK_IS_MATH_VIEW(main_area));
 250
 251   math_view = GTK_MATH_VIEW(main_area);
 252
 253   gtk_math_view_set_font_size(math_view, size);
 254 }
 255
 256 static void
 257 options_anti_aliasing(GtkWidget* widget, gpointer data)
 258 {
 259   gboolean aa = gtk_math_view_get_anti_aliasing(GTK_MATH_VIEW(main_area));
 260   gtk_math_view_set_anti_aliasing(GTK_MATH_VIEW(main_area), !aa);
 261 }
 262
 263 static void
 264 options_transparency(GtkWidget* widget, gpointer data)
 265 {
 266   gboolean t = gtk_math_view_get_transparency(GTK_MATH_VIEW(main_area));
 267   gtk_math_view_set_transparency(GTK_MATH_VIEW(main_area), !t);
 268 }
 269
 270 static void
 271 options_verbosity(GtkWidget* widget, guint level)
 272 {
 273   gtk_math_view_set_log_verbosity(GTK_MATH_VIEW(main_area), level);
 274 }
 275
 276 static void
 277 edit_delete_selection(GtkWidget* widget, gpointer data)
 278 {
 279   if (root_selected != NULL)
 280     {
 281       GdomeException exc;
 282       gtk_math_view_freeze(GTK_MATH_VIEW(main_area));
 283       printf("about to remove element %p\n", root_selected);
 284       delete_element(root_selected);
 285       gdome_el_unref(root_selected, &exc);
 286       g_assert(exc == 0);
 287       root_selected = NULL;
 288       gtk_math_view_thaw(GTK_MATH_VIEW(main_area));
 289     }
 290 }
 291
 292 static void
 293 edit_select_parent(GtkWidget* widget, gpointer data)
 294 {
 295   if (root_selected != NULL)
 296     {
 297       GdomeException exc = 0;
 298       GdomeElement* parent = gdome_cast_el(gdome_n_parentNode(root_selected, &exc));
 299       g_assert(exc == 0);
 300       gdome_el_unref(root_selected, &exc);
 301       g_assert(exc == 0);
 302       root_selected = parent;
 303       gtk_math_view_set_selection(GTK_MATH_VIEW(main_area), root_selected);
 304     }
 305 }
 306
 307 static void
 308 help_about(GtkWidget* widget, gpointer data)
 309 {
 310   GtkWidget* dialog;
 311   GtkWidget* label;
 312   GtkWidget* ok;
 313
 314   dialog = gtk_dialog_new();
 315   label = gtk_label_new("\n    MathML Viewer    \n    Copyright (C) 2000-2002 Luca Padovani    \n");
 316   ok = gtk_button_new_with_label("Close");
 317
 318   gtk_signal_connect_object (GTK_OBJECT (ok), "clicked",
 319                              GTK_SIGNAL_FUNC (gtk_widget_destroy), (gpointer) dialog);
 320   gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->action_area),
 321                      ok);
 322
 323   gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox), label);
 324
 325   gtk_widget_show_all (dialog);
 326 }
 327
 328 #if 0
 329 #if defined(HAVE_GMETADOM)
 330 static void
 331 element_changed(GtkMathView* math_view, GdomeElement* node)
 332 {
 333   GdomeException exc;
 334   GdomeDOMString* name;
 335   GdomeDOMString* ns_uri;
 336
 337   g_return_if_fail(math_view != NULL);
 338   g_return_if_fail(GTK_IS_MATH_VIEW(math_view));
 339
 340   name = gdome_str_mkref("href");
 341   ns_uri = gdome_str_mkref(XLINK_NS_URI);
 342
 343   while (node != NULL && !gdome_el_hasAttributeNS(node, ns_uri, name, &exc))
 344     node = gdome_cast_el(gdome_el_parentNode(node, &exc));
 345
 346   if (node != NULL && gdome_el_hasAttributeNS(node, ns_uri, name, &exc))
 347     gdk_window_set_cursor(GTK_WIDGET(math_view)->window, link_cursor);
 348   else
 349     gdk_window_set_cursor(GTK_WIDGET(math_view)->window, normal_cursor);
 350
 351   gdome_str_unref(name);
 352   gdome_str_unref(ns_uri);
 353 }
 354 #endif
 355
 356 static void
 357 #if defined(HAVE_GMETADOM)
 358 action_changed(GtkMathView* math_view, GdomeElement* node)
 359 #endif
 360 {
 361   g_return_if_fail(math_view != NULL);
 362   g_return_if_fail(GTK_IS_MATH_VIEW(math_view));
 363 }
 364
 365 static void
 366 #if defined(HAVE_GMETADOM)
 367 selection_changed(GtkMathView* math_view, GdomeElement* node)
 368 #endif
 369 {
 370   g_return_if_fail(math_view != NULL);
 371   g_return_if_fail(GTK_IS_MATH_VIEW(math_view));
 372   gtk_math_view_set_selection(math_view, node);
 373
 374   cursor_off();
 375   cursor_ptr = node;
 376   cursor_on();
 377 }
 378
 379 #if defined(HAVE_GMETADOM)
 380 static void
 381 clicked(GtkMathView* math_view, gpointer user_data)
 382 {
 383   GdomeException exc;
 384   GdomeDOMString* name;
 385   GdomeDOMString* ns_uri;
 386   GdomeElement* p;
 387
 388   g_return_if_fail(math_view != NULL);
 389
 390   name = gdome_str_mkref("href");
 391   ns_uri = gdome_str_mkref(XLINK_NS_URI);
 392
 393   p = gtk_math_view_get_element(math_view);
 394   while (p != NULL && !gdome_el_hasAttributeNS(p, ns_uri, name, &exc))
 395     p = gdome_cast_el(gdome_el_parentNode(p, &exc));
 396
 397   if (p != NULL) {
 398     GdomeDOMString* href = gdome_el_getAttributeNS(p, ns_uri, name, &exc);
 399     g_assert(href != NULL);
 400
 401     GUI_load_document(href->str);
 402     gdome_str_unref(href);
 403   } else if (gtk_math_view_get_action(math_view) != NULL)
 404     gtk_math_view_action_toggle(math_view);
 405 }
 406 #endif
 407 #endif
 408
 409 static gint
 410 button_press_event(GtkWidget* widget,
 411                    GdkEventButton* event,
 412                    GtkMathView* math_view)
 413 {
 414   g_return_val_if_fail(event != NULL, FALSE);
 415   g_return_val_if_fail(math_view != NULL, FALSE);
 416
 417   if (event->button == 1)
 418     {
 419       GdomeException exc;
 420
 421       cursor_off();
 422
 423       if (root_selected != NULL)
 424         {
 425           gtk_math_view_reset_selection(math_view, root_selected);
 426           gdome_el_unref(root_selected, &exc);
 427           g_assert(exc == 0);
 428           root_selected = NULL;
 429         }
 430
 431       if (first_selected != NULL)
 432         {
 433           gdome_el_unref(first_selected, &exc);
 434           g_assert(exc == 0);
 435         }
 436
 437       if (last_selected != NULL)
 438         {
 439           gdome_el_unref(last_selected, &exc);
 440           g_assert(exc == 0);
 441           last_selected = NULL;
 442         }
 443
 444       first_selected = gtk_math_view_get_element_at(math_view, event->x, event->y);
 445       button_pressed = TRUE;
 446       selecting = FALSE;
 447     }
 448
 449   return FALSE;
 450 }
 451
 452 static gint
 453 motion_notify_event(GtkWidget* widget,
 454                     GdkEventMotion* event,
 455                     GtkMathView* math_view)
 456 {
 457   g_return_val_if_fail(event != NULL, FALSE);
 458   g_return_val_if_fail(math_view != NULL, FALSE);
 459
 460   if (button_pressed && first_selected != NULL)
 461     {
 462       GdomeException exc;
 463       GdomeElement* el = gtk_math_view_get_element_at(math_view, event->x, event->y);
 464       GdomeElement* root;
 465
 466       selecting = TRUE;
 467
 468       if (el != NULL && el != last_selected)
 469         {
 470           if (last_selected != NULL)
 471             {
 472               gdome_el_unref(last_selected, &exc);
 473               g_assert(exc == 0);
 474             }
 475
 476           last_selected = el;
 477         }
 478
 479       if (last_selected != NULL)
 480         {
 481           root = find_common_ancestor(first_selected, last_selected);
 482           g_assert(root != NULL);
 483
 484           if (root != root_selected)
 485             {
 486               gtk_math_view_freeze(math_view);
 487               if (root_selected != NULL)
 488                 {
 489                   gtk_math_view_reset_selection(math_view, root_selected);
 490                   gdome_el_unref(root_selected, &exc);
 491                   g_assert(exc == 0);
 492                 }
 493               root_selected = root;
 494               gtk_math_view_set_selection(math_view, root_selected);
 495               gtk_math_view_thaw(math_view);
 496             }
 497           else
 498             {
 499               gdome_el_unref(root, &exc);
 500               g_assert(exc == 0);
 501             }
 502         }
 503     }
 504
 505   return FALSE;
 506 }
 507
 508 static gint
 509 button_release_event(GtkWidget* widget,
 510                      GdkEventButton* event,
 511                      GtkMathView* math_view)
 512 {
 513   g_return_val_if_fail(event != NULL, FALSE);
 514   g_return_val_if_fail(math_view != NULL, FALSE);
 515
 516   if (event->button == 1)
 517     {
 518       if (!selecting)
 519         {
 520           cursor_ptr = first_selected;
 521           cursor_on();
 522         }
 523
 524       button_pressed = FALSE;
 525       selecting = FALSE;
 526     }
 527
 528   return FALSE;
 529 }
 530
 531 static gboolean
 532 key_press_event(gpointer context,
 533                 GdkEventKey* event,
 534                 GtkWidget* widget)
 535 {
 536   g_return_val_if_fail(widget != NULL, FALSE);
 537   g_return_val_if_fail(event != NULL, FALSE);
 538   g_return_val_if_fail(context != NULL, FALSE);
 539
 540   if (event->type != GDK_KEY_PRESS) return FALSE;
 541
 542   switch (event->keyval) {
 543   case GDK_Up:
 544   case GDK_KP_Up:
 545     break;
 546   case GDK_Down:
 547   case GDK_KP_Down:
 548     break;
 549   case GDK_Left:
 550   case GDK_KP_Left:
 551     break;
 552   case GDK_Right:
 553   case GDK_KP_Right:
 554     break;
 555   case GDK_Page_Up:
 556   case GDK_KP_Page_Up:
 557     break;
 558   case GDK_Page_Down:
 559   case GDK_KP_Page_Down:
 560     break;
 561   case GDK_Home:
 562   case GDK_KP_Home:
 563     break;
 564   case GDK_End:
 565   case GDK_KP_End:
 566     break;
 567   default:
 568     if (event->keyval < 0x80) push_char(context, event->keyval);
 569     return FALSE;
 570   }
 571
 572   return TRUE;
 573 }
 574
 575 static void
 576 create_widget_set(gpointer context)
 577 {
 578   GtkWidget* main_vbox;
 579   GtkWidget* menu_bar;
 580
 581   main_vbox = gtk_vbox_new(FALSE, 1);
 582   gtk_container_border_width(GTK_CONTAINER(main_vbox), 1);
 583   gtk_container_add(GTK_CONTAINER(window), main_vbox);
 584   gtk_widget_show(main_vbox);
 585
 586   menu_bar = get_main_menu();
 587   gtk_box_pack_start(GTK_BOX(main_vbox), menu_bar, FALSE, TRUE, 0);
 588   gtk_widget_show(menu_bar);
 589
 590   main_area = gtk_math_view_new(NULL, NULL);
 591   gtk_widget_show(main_area);
 592
 593   //gtk_math_view_set_log_verbosity(GTK_MATH_VIEW(main_area), 3);
 594
 595 #if 0
 596   gtk_signal_connect_object (GTK_OBJECT (main_area),
 597                              "selection_changed", GTK_SIGNAL_FUNC (selection_changed),
 598                              (gpointer) main_area);
 599
 600   gtk_signal_connect_object (GTK_OBJECT (main_area),
 601                              "element_changed", GTK_SIGNAL_FUNC (element_changed),
 602                              (gpointer) main_area);
 603
 604   gtk_signal_connect_object (GTK_OBJECT (main_area),
 605                              "action_changed", GTK_SIGNAL_FUNC (action_changed),
 606                              (gpointer) main_area);
 607
 608   gtk_signal_connect_object (GTK_OBJECT (main_area),
 609                              "clicked", GTK_SIGNAL_FUNC(clicked),
 610                              (gpointer) main_area);
 611 #endif
 612
 613   gtk_signal_connect_object (GTK_OBJECT (main_area),
 614                              "button_press_event", GTK_SIGNAL_FUNC(button_press_event),
 615                              (gpointer) main_area);
 616
 617   gtk_signal_connect_object (GTK_OBJECT (main_area),
 618                              "button_release_event", GTK_SIGNAL_FUNC(button_release_event),
 619                              (gpointer) main_area);
 620
 621   gtk_signal_connect_object (GTK_OBJECT (main_area),
 622                              "motion_notify_event", GTK_SIGNAL_FUNC(motion_notify_event),
 623                              (gpointer) main_area);
 624
 625   gtk_signal_connect_object (GTK_OBJECT(window),
 626                              "key_press_event", GTK_SIGNAL_FUNC(key_press_event),
 627                              context);
 628
 629   gtk_widget_add_events(GTK_WIDGET(main_area),
 630                         GDK_BUTTON_PRESS_MASK
 631                         | GDK_BUTTON_RELEASE_MASK
 632                         | GDK_POINTER_MOTION_MASK
 633                         | GDK_KEY_PRESS_MASK);
 634
 635   scrolled_area = gtk_scrolled_window_new(NULL, NULL);
 636   gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_area),
 637                                  GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
 638
 639   gtk_widget_show(scrolled_area);
 640   gtk_container_add(GTK_CONTAINER(scrolled_area), main_area);
 641   gtk_box_pack_start(GTK_BOX(main_vbox), scrolled_area, TRUE, TRUE, 0);
 642
 643   status_bar = gtk_statusbar_new();
 644   gtk_widget_show(status_bar);
 645   gtk_box_pack_start(GTK_BOX(main_vbox), status_bar, FALSE, TRUE, 0);
 646   statusbar_context = gtk_statusbar_get_context_id(GTK_STATUSBAR(status_bar), "filename");
 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   gtk_menu_item_activate(font_size_item);
 654 }
 655
 656 GtkWidget*
 657 get_main_menu()
 658 {
 659   GtkItemFactory* item_factory;
 660   GtkAccelGroup* accel_group;
 661   GtkWidget* menu_item;
 662
 663   gint nmenu_items = sizeof(menu_items) / sizeof(menu_items[0]);
 664
 665   accel_group = gtk_accel_group_new();
 666
 667   item_factory = gtk_item_factory_new(GTK_TYPE_MENU_BAR, "<main>", accel_group);
 668
 669   gtk_item_factory_create_items(item_factory, nmenu_items, menu_items, NULL);
 670
 671   gtk_window_add_accel_group(GTK_WINDOW(window), accel_group);
 672
 673   menu_item = gtk_item_factory_get_widget(item_factory, "/Options/Anti Aliasing");
 674   anti_aliasing_item = GTK_MENU_ITEM(menu_item);
 675
 676   menu_item = gtk_item_factory_get_widget(item_factory, "/Options/Transparency");
 677   transparency_item = GTK_MENU_ITEM(menu_item);
 678
 679   /* !!!BEWARE!!! the default font size must be kept aligned with the definition
 680    * in math-engine-configuration.xml
 681    */
 682   menu_item = gtk_item_factory_get_widget(item_factory, "/Options/Default Font Size/12pt");
 683   font_size_item = GTK_MENU_ITEM(menu_item);
 684
 685   return gtk_item_factory_get_widget(item_factory, "<main>");
 686 }