Initial checkin: merged embed/gecko from xulrunner branch to embed/xulrunner, and svn copied embed/mozilla to embed/xulrunner/embed. Not integreated with the build yet.

svn path=/trunk/; revision=7297

1 files changed, 1145 insertions, 0 deletions

diff --git a/embed/xulrunner/tests/testgeckoembed.cpp b/embed/xulrunner/tests/testgeckoembed.cpp
new file mode 100644
index 000000000..1b9a888b6
--- /dev/null
+++ b/embed/xulrunner/tests/testgeckoembed.cpp
@@ -0,0 +1,1145 @@
+/*
+ *  Copyright © Christopher Blizzard
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU Lesser General Public License as published by
+ *  the Free Software Foundation; either version 2.1, or (at your option)
+ *  any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ *  ---------------------------------------------------------------------------
+ *  Derived from Mozilla.org code, which had the following attributions:
+ *
+ *  The Original Code is mozilla.org code.
+ *
+ *  The Initial Developer of the Original Code is
+ *  Christopher Blizzard. Portions created by Christopher Blizzard are Copyright © Christopher Blizzard.  All Rights Reserved.
+ *  Portions created by the Initial Developer are Copyright © 2001
+ *  the Initial Developer. All Rights Reserved.
+ *
+ *  Contributor(s):
+ *    Christopher Blizzard <blizzard@mozilla.org>
+ *  ---------------------------------------------------------------------------
+ *
+ *  $Id$
+ */
+ 
+#include <mozilla-config.h>
+#include <config.h>
+
+#include "gecko-init.h"
+#include "gecko-embed.h"
+#include "gecko-embed-single.h"
+#include "gecko-dom-event.h"
+#include "gecko-dom-event-internal.h"
+#include "gecko-embed-types.h"
+
+#include <gtk/gtk.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+// mozilla specific headers
+#include "nsIDOMKeyEvent.h"
+#include "nsIDOMMouseEvent.h"
+#include "nsIDOMUIEvent.h"
+
+#include <nsStringAPI.h>
+#include <nsCOMPtr.h>
+
+#define XPCOM_GLUE
+#include <nsXPCOMGlue.h>
+
+typedef struct _TestGeckoBrowser {
+  GtkWidget  *topLevelWindow;
+  GtkWidget  *topLevelVBox;
+  GtkWidget  *menuBar;
+  GtkWidget  *fileMenuItem;
+  GtkWidget  *fileMenu;
+  GtkWidget  *fileOpenNewBrowser;
+  GtkWidget  *fileStream;
+  GtkWidget  *fileClose;
+  GtkWidget  *fileQuit;
+  GtkWidget  *toolbarHBox;
+  GtkWidget  *toolbar;
+  GtkWidget  *backButton;
+  GtkWidget  *stopButton;
+  GtkWidget  *forwardButton;
+  GtkWidget  *reloadButton;
+  GtkWidget  *urlEntry;
+  GtkWidget  *mozEmbed;
+  GtkWidget  *progressAreaHBox;
+  GtkWidget  *progressBar;
+  GtkWidget  *statusAlign;
+  GtkWidget  *statusBar;
+  const char *statusMessage;
+  int         loadPercent;
+  int         bytesLoaded;
+  int         maxBytesLoaded;
+  char       *tempMessage;
+  gboolean menuBarOn;
+  gboolean toolBarOn;
+  gboolean locationBarOn;
+  gboolean statusBarOn;
+
+} TestGeckoBrowser;
+
+// the list of browser windows currently open
+GList *browser_list = g_list_alloc();
+
+static TestGeckoBrowser *new_gecko_browser    (guint32 chromeMask);
+static void            set_browser_visibility (TestGeckoBrowser *browser,
+					       gboolean visibility);
+
+static int num_browsers = 0;
+
+// callbacks from the UI
+static void     back_clicked_cb    (GtkButton   *button, 
+				    TestGeckoBrowser *browser);
+static void     stop_clicked_cb    (GtkButton   *button,
+				    TestGeckoBrowser *browser);
+static void     forward_clicked_cb (GtkButton   *button,
+				    TestGeckoBrowser *browser);
+static void     reload_clicked_cb  (GtkButton   *button,
+				    TestGeckoBrowser *browser);
+static void     url_activate_cb    (GtkEditable *widget, 
+				    TestGeckoBrowser *browser);
+static void     menu_open_new_cb   (GtkMenuItem *menuitem,
+				    TestGeckoBrowser *browser);
+static void     menu_stream_cb     (GtkMenuItem *menuitem,
+				    TestGeckoBrowser *browser);
+static void     menu_close_cb      (GtkMenuItem *menuitem,
+				    TestGeckoBrowser *browser);
+static void     menu_quit_cb       (GtkMenuItem *menuitem,
+				    TestGeckoBrowser *browser);
+static gboolean delete_cb          (GtkWidget *widget, GdkEventAny *event,
+				    TestGeckoBrowser *browser);
+static void     destroy_cb         (GtkWidget *widget,
+				    TestGeckoBrowser *browser);
+
+// callbacks from the widget
+static void location_changed_cb  (GeckoEmbed *embed, TestGeckoBrowser *browser);
+static void title_changed_cb     (GeckoEmbed *embed, TestGeckoBrowser *browser);
+static void load_started_cb      (GeckoEmbed *embed, TestGeckoBrowser *browser);
+static void load_finished_cb     (GeckoEmbed *embed, TestGeckoBrowser *browser);
+static void net_state_change_cb  (GeckoEmbed *embed, gint flags,
+				  guint status, TestGeckoBrowser *browser);
+static void net_state_change_all_cb (GeckoEmbed *embed, const char *uri,
+				     gint flags, guint status,
+				     TestGeckoBrowser *browser);
+static void progress_change_cb   (GeckoEmbed *embed, gint cur, gint max,
+				  TestGeckoBrowser *browser);
+static void progress_change_all_cb (GeckoEmbed *embed, const char *uri,
+				    gint cur, gint max,
+				    TestGeckoBrowser *browser);
+static void link_message_cb      (GeckoEmbed *embed, TestGeckoBrowser *browser);
+static void js_status_cb         (GeckoEmbed *embed, TestGeckoBrowser *browser);
+static void new_window_cb        (GeckoEmbed *embed,
+				  GeckoEmbed **retval, guint chromemask,
+				  TestGeckoBrowser *browser);
+static void visibility_cb        (GeckoEmbed *embed, 
+				  gboolean visibility,
+				  TestGeckoBrowser *browser);
+static void destroy_brsr_cb      (GeckoEmbed *embed, TestGeckoBrowser *browser);
+static gint open_uri_cb          (GeckoEmbed *embed, const char *uri,
+				  TestGeckoBrowser *browser);
+static void size_to_cb           (GeckoEmbed *embed, gint width,
+				  gint height, TestGeckoBrowser *browser);
+static gboolean dom_key_down_cb      (GeckoEmbed *, GeckoDOMEvent *event,
+				  TestGeckoBrowser *browser);
+static gboolean dom_key_press_cb     (GeckoEmbed *, GeckoDOMEvent *event,
+				  TestGeckoBrowser *browser);
+static gboolean dom_key_up_cb        (GeckoEmbed *, GeckoDOMEvent *event,
+				  TestGeckoBrowser *browser);
+static gboolean dom_mouse_down_cb    (GeckoEmbed *, GeckoDOMEvent *event,
+				  TestGeckoBrowser *browser);
+static gboolean dom_mouse_up_cb      (GeckoEmbed *, GeckoDOMEvent *event,
+				  TestGeckoBrowser *browser);
+static gboolean dom_mouse_click_cb   (GeckoEmbed *, GeckoDOMEvent *event,
+				  TestGeckoBrowser *browser);
+static gboolean dom_mouse_dbl_click_cb (GeckoEmbed *embed, 
+				  GeckoDOMEvent *event,
+				  TestGeckoBrowser *browser);
+static gboolean dom_mouse_over_cb    (GeckoEmbed *, GeckoDOMEvent *event,
+				  TestGeckoBrowser *browser);
+static gboolean dom_mouse_out_cb     (GeckoEmbed *, GeckoDOMEvent *event,
+				  TestGeckoBrowser *browser);
+static gboolean dom_activate_cb      (GeckoEmbed *, GeckoDOMEvent *event,
+				  TestGeckoBrowser *browser);
+static gboolean dom_focus_in_cb      (GeckoEmbed *, GeckoDOMEvent *event,
+				  TestGeckoBrowser *browser);
+static gboolean dom_focus_out_cb     (GeckoEmbed *, GeckoDOMEvent *event,
+				  TestGeckoBrowser *browser);
+static gboolean dom_context_menu_cb     (GeckoEmbed *, GeckoDOMEvent *event,
+				  TestGeckoBrowser *browser);
+
+// callbacks from the singleton object
+static void new_window_orphan_cb (GeckoEmbedSingle *embed,
+				  GeckoEmbed **retval, guint chromemask,
+				  gpointer data);
+
+// some utility functions
+static void update_status_bar_text  (TestGeckoBrowser *browser);
+static void update_temp_message     (TestGeckoBrowser *browser,
+				     const char *message);
+static void update_nav_buttons      (TestGeckoBrowser *browser);
+
+int
+main(int argc, char **argv)
+{
+  //g_setenv ("MOZILLA_FIVE_HOME", GECKO_HOME, FALSE);
+
+  gtk_init(&argc, &argv);
+
+  static const GREVersionRange greVersion = {
+    "1.9a", PR_TRUE,
+    "2", PR_TRUE
+  };
+
+  char xpcomPath[PATH_MAX];
+
+  nsresult rv = GRE_GetGREPathWithProperties(&greVersion, 1, nsnull, 0,
+                                             xpcomPath, sizeof(xpcomPath));
+  if (NS_FAILED(rv)) {
+    fprintf(stderr, "Couldn't find a compatible GRE.\n");
+    return 1;
+  }
+
+  rv = XPCOMGlueStartup(xpcomPath);
+  if (NS_FAILED(rv)) {
+    fprintf(stderr, "Couldn't start XPCOM.");
+    return 1;
+  }
+
+  char *lastSlash = strrchr(xpcomPath, '/');
+  if (lastSlash)
+    *lastSlash = '\0';
+
+  
+  char *home_path;
+  char *full_path;
+  home_path = getenv("HOME");
+  if (!home_path) {
+    fprintf(stderr, "Failed to get HOME\n");
+    exit(1);
+  }
+
+  
+  full_path = g_strdup_printf("%s/%s", home_path, ".TestGtkEmbed");
+  
+  if (!gecko_init_with_profile (xpcomPath, full_path, "TestGtkEmbed")) {
+    fprintf(stderr, "Failed gecko_init_with_profile\n");
+    exit(1);
+  }
+
+  // get the singleton object and hook up to its new window callback
+  // so we can create orphaned windows.
+
+  GeckoEmbedSingle *single;
+
+  single = gecko_embed_single_get();
+  if (!single) {
+    fprintf(stderr, "Failed to get singleton embed object!\n");
+    exit(1);
+  }
+
+  g_signal_connect (single, "new-window-orphan",
+		    G_CALLBACK (new_window_orphan_cb), NULL);
+
+
+  TestGeckoBrowser *browser = new_gecko_browser(GECKO_EMBED_FLAG_DEFAULTCHROME);
+
+  // set our minimum size
+  gtk_widget_set_usize(browser->mozEmbed, 400, 400);
+
+  set_browser_visibility(browser, TRUE);
+
+  if (argc > 1)
+    gecko_embed_load_url(GECKO_EMBED(browser->mozEmbed), argv[1]);
+
+  gtk_main();
+
+  gecko_shutdown ();
+}
+
+static TestGeckoBrowser *
+new_gecko_browser(guint32 chromeMask)
+{
+  guint32         actualChromeMask = chromeMask;
+  TestGeckoBrowser *browser = 0;
+
+  num_browsers++;
+
+  browser = g_new0(TestGeckoBrowser, 1);
+
+  browser_list = g_list_prepend(browser_list, browser);
+
+  browser->menuBarOn = FALSE;
+  browser->toolBarOn = FALSE;
+  browser->locationBarOn = FALSE;
+  browser->statusBarOn = FALSE;
+
+  g_print("new_gecko_browser\n");
+
+//   if (chromeMask == GECKO_EMBED_FLAG_DEFAULTCHROME)
+//     actualChromeMask = GECKO_EMBED_FLAG_ALLCHROME;
+
+  /* FIXMEchpe find out WHY the chrome masks we get from gecko as so weird */
+  actualChromeMask = 0xffffffff;
+
+  if (actualChromeMask & GECKO_EMBED_FLAG_MENUBARON)
+  {
+    browser->menuBarOn = TRUE;
+    g_print("\tmenu bar\n");
+  }
+  if (actualChromeMask & GECKO_EMBED_FLAG_TOOLBARON)
+  {
+    browser->toolBarOn = TRUE;
+    g_print("\ttool bar\n");
+  }
+  if (actualChromeMask & GECKO_EMBED_FLAG_LOCATIONBARON)
+  {
+    browser->locationBarOn = TRUE;
+    g_print("\tlocation bar\n");
+  }
+  if (actualChromeMask & GECKO_EMBED_FLAG_STATUSBARON)
+  {
+    browser->statusBarOn = TRUE;
+    g_print("\tstatus bar\n");
+  }
+
+  // create our new toplevel window
+  browser->topLevelWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+  // new vbox
+  browser->topLevelVBox = gtk_vbox_new(FALSE, 0);
+  // add it to the toplevel window
+  gtk_container_add(GTK_CONTAINER(browser->topLevelWindow),
+		    browser->topLevelVBox);
+  // create our menu bar
+  browser->menuBar = gtk_menu_bar_new();
+  // create the file menu
+  browser->fileMenuItem = gtk_menu_item_new_with_label("File");
+  browser->fileMenu = gtk_menu_new();
+  gtk_menu_item_set_submenu (GTK_MENU_ITEM(browser->fileMenuItem),
+			     browser->fileMenu);
+
+  browser->fileOpenNewBrowser = 
+    gtk_menu_item_new_with_label("Open New Browser");
+  gtk_menu_append(GTK_MENU(browser->fileMenu),
+		  browser->fileOpenNewBrowser);
+  
+  browser->fileStream =
+    gtk_menu_item_new_with_label("Test Stream");
+  gtk_menu_append(GTK_MENU(browser->fileMenu),
+		  browser->fileStream);
+
+  browser->fileClose =
+    gtk_menu_item_new_with_label("Close");
+  gtk_menu_append(GTK_MENU(browser->fileMenu),
+		  browser->fileClose);
+
+  browser->fileQuit =
+    gtk_menu_item_new_with_label("Quit");
+  gtk_menu_append(GTK_MENU(browser->fileMenu),
+		  browser->fileQuit);
+  
+  // append it
+  gtk_menu_bar_append(GTK_MENU_BAR(browser->menuBar), browser->fileMenuItem);
+
+  // add it to the vbox
+  gtk_box_pack_start(GTK_BOX(browser->topLevelVBox),
+		     browser->menuBar,
+		     FALSE, // expand
+		     FALSE, // fill
+		     0);    // padding
+  // create the hbox that will contain the toolbar and the url text entry bar
+  browser->toolbarHBox = gtk_hbox_new(FALSE, 0);
+  // add that hbox to the vbox
+  gtk_box_pack_start(GTK_BOX(browser->topLevelVBox), 
+		     browser->toolbarHBox,
+		     FALSE, // expand
+		     FALSE, // fill
+		     0);    // padding
+  // new horiz toolbar with buttons + icons
+  browser->toolbar = gtk_toolbar_new();
+  gtk_toolbar_set_orientation(GTK_TOOLBAR(browser->toolbar),
+			      GTK_ORIENTATION_HORIZONTAL);
+  gtk_toolbar_set_style(GTK_TOOLBAR(browser->toolbar),
+			GTK_TOOLBAR_BOTH);
+
+  // add it to the hbox
+  gtk_box_pack_start(GTK_BOX(browser->toolbarHBox), browser->toolbar,
+		   FALSE, // expand
+		   FALSE, // fill
+		   0);    // padding
+  // new back button
+  browser->backButton =
+    gtk_toolbar_append_item(GTK_TOOLBAR(browser->toolbar),
+			    "Back",
+			    "Go Back",
+			    "Go Back",
+			    0, // XXX replace with icon
+			    GTK_SIGNAL_FUNC(back_clicked_cb),
+			    browser);
+  // new stop button
+  browser->stopButton = 
+    gtk_toolbar_append_item(GTK_TOOLBAR(browser->toolbar),
+			    "Stop",
+			    "Stop",
+			    "Stop",
+			    0, // XXX replace with icon
+			    GTK_SIGNAL_FUNC(stop_clicked_cb),
+			    browser);
+  // new forward button
+  browser->forwardButton =
+    gtk_toolbar_append_item(GTK_TOOLBAR(browser->toolbar),
+			    "Forward",
+			    "Forward",
+			    "Forward",
+			    0, // XXX replace with icon
+			    GTK_SIGNAL_FUNC(forward_clicked_cb),
+			    browser);
+  // new reload button
+  browser->reloadButton = 
+    gtk_toolbar_append_item(GTK_TOOLBAR(browser->toolbar),
+			    "Reload",
+			    "Reload",
+			    "Reload",
+			    0, // XXX replace with icon
+			    GTK_SIGNAL_FUNC(reload_clicked_cb),
+			    browser);
+  // create the url text entry
+  browser->urlEntry = gtk_entry_new();
+  // add it to the hbox
+  gtk_box_pack_start(GTK_BOX(browser->toolbarHBox), browser->urlEntry,
+		     TRUE, // expand
+		     TRUE, // fill
+		     0);    // padding
+  // create our new gtk moz embed widget
+  browser->mozEmbed = gecko_embed_new();
+  // add it to the toplevel vbox
+  gtk_box_pack_start(GTK_BOX(browser->topLevelVBox), browser->mozEmbed,
+		     TRUE, // expand
+		     TRUE, // fill
+		     0);   // padding
+  // create the new hbox for the progress area
+  browser->progressAreaHBox = gtk_hbox_new(FALSE, 0);
+  // add it to the vbox
+  gtk_box_pack_start(GTK_BOX(browser->topLevelVBox), browser->progressAreaHBox,
+		     FALSE, // expand
+		     FALSE, // fill
+		     0);   // padding
+  // create our new progress bar
+  browser->progressBar = gtk_progress_bar_new();
+  // add it to the hbox
+  gtk_box_pack_start(GTK_BOX(browser->progressAreaHBox), browser->progressBar,
+		     FALSE, // expand
+		     FALSE, // fill
+		     0); // padding
+  
+  // create our status area and the alignment object that will keep it
+  // from expanding
+  browser->statusAlign = gtk_alignment_new(0, 0, 1, 1);
+  gtk_widget_set_usize(browser->statusAlign, 1, -1);
+  // create the status bar
+  browser->statusBar = gtk_statusbar_new();
+  gtk_container_add(GTK_CONTAINER(browser->statusAlign), browser->statusBar);
+  // add it to the hbox
+  gtk_box_pack_start(GTK_BOX(browser->progressAreaHBox), browser->statusAlign,
+		     TRUE, // expand
+		     TRUE, // fill
+		     0);   // padding
+  // by default none of the buttons are marked as sensitive.
+  gtk_widget_set_sensitive(browser->backButton, FALSE);
+  gtk_widget_set_sensitive(browser->stopButton, FALSE);
+  gtk_widget_set_sensitive(browser->forwardButton, FALSE);
+  gtk_widget_set_sensitive(browser->reloadButton, FALSE);
+  
+  // catch the destruction of the toplevel window
+  gtk_signal_connect(GTK_OBJECT(browser->topLevelWindow), "delete_event",
+		     GTK_SIGNAL_FUNC(delete_cb), browser);
+
+  // hook up the activate signal to the right callback
+  gtk_signal_connect(GTK_OBJECT(browser->urlEntry), "activate",
+		     GTK_SIGNAL_FUNC(url_activate_cb), browser);
+
+  // hook up to the open new browser activation
+  gtk_signal_connect(GTK_OBJECT(browser->fileOpenNewBrowser), "activate",
+		     GTK_SIGNAL_FUNC(menu_open_new_cb), browser);
+  // hook up to the stream test
+  gtk_signal_connect(GTK_OBJECT(browser->fileStream), "activate",
+		     GTK_SIGNAL_FUNC(menu_stream_cb), browser);
+  // close this window
+  gtk_signal_connect(GTK_OBJECT(browser->fileClose), "activate",
+		     GTK_SIGNAL_FUNC(menu_close_cb), browser);
+  // quit the application
+  gtk_signal_connect(GTK_OBJECT(browser->fileQuit), "activate",
+		     GTK_SIGNAL_FUNC(menu_quit_cb), browser);
+
+  // hook up the location change to update the urlEntry
+  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "location",
+		     GTK_SIGNAL_FUNC(location_changed_cb), browser);
+  // hook up the title change to update the window title
+  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "title",
+		     GTK_SIGNAL_FUNC(title_changed_cb), browser);
+  // hook up the start and stop signals
+  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "net_start",
+		     GTK_SIGNAL_FUNC(load_started_cb), browser);
+  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "net_stop",
+		     GTK_SIGNAL_FUNC(load_finished_cb), browser);
+  // hook up to the change in network status
+  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "net_state",
+		     GTK_SIGNAL_FUNC(net_state_change_cb), browser);
+  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "net_state_all",
+		     GTK_SIGNAL_FUNC(net_state_change_all_cb), browser);
+  // hookup to changes in progress
+  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "progress",
+		     GTK_SIGNAL_FUNC(progress_change_cb), browser);
+  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "progress_all",
+		     GTK_SIGNAL_FUNC(progress_change_all_cb), browser);
+  // hookup to changes in over-link message
+  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "link_message",
+		     GTK_SIGNAL_FUNC(link_message_cb), browser);
+  // hookup to changes in js status message
+  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "js_status",
+		     GTK_SIGNAL_FUNC(js_status_cb), browser);
+  // hookup to see whenever a new window is requested
+  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "new_window",
+		     GTK_SIGNAL_FUNC(new_window_cb), browser);
+  // hookup to any requested visibility changes
+  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "visibility",
+		     GTK_SIGNAL_FUNC(visibility_cb), browser);
+  // hookup to the signal that says that the browser requested to be
+  // destroyed
+  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "destroy_browser",
+		     GTK_SIGNAL_FUNC(destroy_brsr_cb), browser);
+  // hookup to the signal that is called when someone clicks on a link
+  // to load a new uri
+  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "open_uri",
+		     GTK_SIGNAL_FUNC(open_uri_cb), browser);
+  // this signal is emitted when there's a request to change the
+  // containing browser window to a certain height, like with width
+  // and height args for a window.open in javascript
+  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "size_to",
+		     GTK_SIGNAL_FUNC(size_to_cb), browser);
+  // key event signals
+  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_key_down",
+		     GTK_SIGNAL_FUNC(dom_key_down_cb), browser);
+  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_key_press",
+		     GTK_SIGNAL_FUNC(dom_key_press_cb), browser);
+  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_key_up",
+		     GTK_SIGNAL_FUNC(dom_key_up_cb), browser);
+  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_mouse_down",
+		     GTK_SIGNAL_FUNC(dom_mouse_down_cb), browser);
+  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_mouse_up",
+		     GTK_SIGNAL_FUNC(dom_mouse_up_cb), browser);
+  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_mouse_click",
+		     GTK_SIGNAL_FUNC(dom_mouse_click_cb), browser);
+  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_mouse_dbl_click",
+		     GTK_SIGNAL_FUNC(dom_mouse_dbl_click_cb), browser);
+  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_mouse_over",
+		     GTK_SIGNAL_FUNC(dom_mouse_over_cb), browser);
+  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_mouse_out",
+		     GTK_SIGNAL_FUNC(dom_mouse_out_cb), browser);
+  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_activate",
+		     GTK_SIGNAL_FUNC(dom_activate_cb), browser);
+  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_focus_in",
+		     GTK_SIGNAL_FUNC(dom_focus_in_cb), browser);
+  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_focus_out",
+		     GTK_SIGNAL_FUNC(dom_focus_out_cb), browser);
+  g_signal_connect(browser->mozEmbed, "dom-context-menu",
+		     GTK_SIGNAL_FUNC(dom_context_menu_cb), browser);
+  // hookup to when the window is destroyed
+  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "destroy",
+		     GTK_SIGNAL_FUNC(destroy_cb), browser);
+  
+  // set the chrome type so it's stored in the object
+  gecko_embed_set_chrome_mask(GECKO_EMBED(browser->mozEmbed),
+				actualChromeMask);
+
+  gtk_widget_show_all (browser->topLevelVBox);
+
+  return browser;
+}
+
+void
+set_browser_visibility (TestGeckoBrowser *browser, gboolean visibility)
+{
+  if (!visibility)
+  {
+    gtk_widget_hide(browser->topLevelWindow);
+    return;
+  }
+
+  if (browser->menuBarOn)
+    gtk_widget_show_all(browser->menuBar);
+  else
+    gtk_widget_hide_all(browser->menuBar);
+
+  // since they are on the same line here...
+  if (browser->toolBarOn || browser->locationBarOn)
+    gtk_widget_show_all(browser->toolbarHBox);
+  else 
+    gtk_widget_hide_all(browser->toolbarHBox);
+
+  if (browser->statusBarOn)
+    gtk_widget_show_all(browser->progressAreaHBox);
+  else
+    gtk_widget_hide_all(browser->progressAreaHBox);
+
+  gtk_widget_show(browser->mozEmbed);
+  gtk_widget_show(browser->topLevelVBox);
+  gtk_widget_show(browser->topLevelWindow);
+}
+
+void
+back_clicked_cb (GtkButton *button, TestGeckoBrowser *browser)
+{
+  gecko_embed_go_back(GECKO_EMBED(browser->mozEmbed));
+}
+
+void
+stop_clicked_cb (GtkButton *button, TestGeckoBrowser *browser)
+{
+  g_print("stop_clicked_cb\n");
+  gecko_embed_stop_load(GECKO_EMBED(browser->mozEmbed));
+}
+
+void
+forward_clicked_cb (GtkButton *button, TestGeckoBrowser *browser)
+{
+  g_print("forward_clicked_cb\n");
+  gecko_embed_go_forward(GECKO_EMBED(browser->mozEmbed));
+}
+
+void
+reload_clicked_cb  (GtkButton *button, TestGeckoBrowser *browser)
+{
+  g_print("reload_clicked_cb\n");
+  GdkModifierType state = (GdkModifierType)0;
+  gint x, y;
+  gdk_window_get_pointer(NULL, &x, &y, &state);
+  
+  gecko_embed_reload(GECKO_EMBED(browser->mozEmbed),
+		       (state & GDK_SHIFT_MASK) ?
+		       GECKO_EMBED_FLAG_RELOADBYPASSCACHE : 
+		       GECKO_EMBED_FLAG_RELOADNORMAL);
+}
+
+void 
+stream_clicked_cb  (GtkButton   *button, TestGeckoBrowser *browser)
+{
+  const char *data;
+  const char *data2;
+  data = "<html>Hi";
+  data2 = " there</html>\n";
+  g_print("stream_clicked_cb\n");
+  gecko_embed_open_stream(GECKO_EMBED(browser->mozEmbed),
+			    "file://", "text/html");
+  gecko_embed_append_data(GECKO_EMBED(browser->mozEmbed),
+			    data, strlen(data));
+  gecko_embed_append_data(GECKO_EMBED(browser->mozEmbed),
+			    data2, strlen(data2));
+  gecko_embed_close_stream(GECKO_EMBED(browser->mozEmbed));
+}
+
+void
+url_activate_cb    (GtkEditable *widget, TestGeckoBrowser *browser)
+{
+  gchar *text = gtk_editable_get_chars(widget, 0, -1);
+  g_print("loading url %s\n", text);
+  gecko_embed_load_url(GECKO_EMBED(browser->mozEmbed), text);
+  g_free(text);
+}
+
+void
+menu_open_new_cb   (GtkMenuItem *menuitem, TestGeckoBrowser *browser)
+{
+  g_print("opening new browser.\n");
+  TestGeckoBrowser *newBrowser = 
+    new_gecko_browser(GECKO_EMBED_FLAG_DEFAULTCHROME);
+  gtk_widget_set_usize(newBrowser->mozEmbed, 400, 400);
+  set_browser_visibility(newBrowser, TRUE);
+}
+
+void
+menu_stream_cb     (GtkMenuItem *menuitem, TestGeckoBrowser *browser)
+{
+  g_print("menu_stream_cb\n");
+  const char *data;
+  const char *data2;
+  data = "<html>Hi";
+  data2 = " there</html>\n";
+  g_print("stream_clicked_cb\n");
+  gecko_embed_open_stream(GECKO_EMBED(browser->mozEmbed),
+			    "file://", "text/html");
+  gecko_embed_append_data(GECKO_EMBED(browser->mozEmbed),
+			    data, strlen(data));
+  gecko_embed_append_data(GECKO_EMBED(browser->mozEmbed),
+			    data2, strlen(data2));
+  gecko_embed_close_stream(GECKO_EMBED(browser->mozEmbed));
+}
+
+void
+menu_close_cb (GtkMenuItem *menuitem, TestGeckoBrowser *browser)
+{
+  gtk_widget_destroy(browser->topLevelWindow);
+}
+
+void
+menu_quit_cb (GtkMenuItem *menuitem, TestGeckoBrowser *browser)
+{
+  TestGeckoBrowser *tmpBrowser;
+  GList *tmp_list = browser_list;
+  tmpBrowser = (TestGeckoBrowser *)tmp_list->data;
+  while (tmpBrowser) {
+    tmp_list = tmp_list->next;
+    gtk_widget_destroy(tmpBrowser->topLevelWindow);
+    tmpBrowser = (TestGeckoBrowser *)tmp_list->data;
+  }
+}
+
+gboolean
+delete_cb(GtkWidget *widget, GdkEventAny *event, TestGeckoBrowser *browser)
+{
+  g_print("delete_cb\n");
+  gtk_widget_destroy(widget);
+  return TRUE;
+}
+
+void
+destroy_cb         (GtkWidget *widget, TestGeckoBrowser *browser)
+{
+  GList *tmp_list;
+  g_print("destroy_cb\n");
+  num_browsers--;
+  tmp_list = g_list_find(browser_list, browser);
+  browser_list = g_list_remove_link(browser_list, tmp_list);
+  if (browser->tempMessage)
+    g_free(browser->tempMessage);
+  if (num_browsers == 0)
+    gtk_main_quit();
+}
+
+void
+location_changed_cb (GeckoEmbed *embed, TestGeckoBrowser *browser)
+{
+  char *newLocation;
+  int   newPosition = 0;
+  g_print("location_changed_cb\n");
+  newLocation = gecko_embed_get_location(embed);
+  if (newLocation)
+  {
+    gtk_editable_delete_text(GTK_EDITABLE(browser->urlEntry), 0, -1);
+    gtk_editable_insert_text(GTK_EDITABLE(browser->urlEntry),
+			     newLocation, strlen(newLocation), &newPosition);
+    g_free(newLocation);
+  }
+  else
+    g_print("failed to get location!\n");
+  // always make sure to clear the tempMessage.  it might have been
+  // set from the link before a click and we wouldn't have gotten the
+  // callback to unset it.
+  update_temp_message(browser, 0);
+  // update the nav buttons on a location change
+  update_nav_buttons(browser);
+}
+
+void
+title_changed_cb    (GeckoEmbed *embed, TestGeckoBrowser *browser)
+{
+  char *newTitle;
+  g_print("title_changed_cb\n");
+  newTitle = gecko_embed_get_title(embed);
+  if (newTitle)
+  {
+    gtk_window_set_title(GTK_WINDOW(browser->topLevelWindow), newTitle);
+    g_free(newTitle);
+  }
+  
+}
+
+void
+load_started_cb     (GeckoEmbed *embed, TestGeckoBrowser *browser)
+{
+  g_print("load_started_cb\n");
+  gtk_widget_set_sensitive(browser->stopButton, TRUE);
+  gtk_widget_set_sensitive(browser->reloadButton, FALSE);
+  browser->loadPercent = 0;
+  browser->bytesLoaded = 0;
+  browser->maxBytesLoaded = 0;
+  update_status_bar_text(browser);
+}
+
+void
+load_finished_cb    (GeckoEmbed *embed, TestGeckoBrowser *browser)
+{
+  g_print("load_finished_cb\n");
+  gtk_widget_set_sensitive(browser->stopButton, FALSE);
+  gtk_widget_set_sensitive(browser->reloadButton, TRUE);
+  browser->loadPercent = 0;
+  browser->bytesLoaded = 0;
+  browser->maxBytesLoaded = 0;
+  update_status_bar_text(browser);
+  gtk_progress_set_percentage(GTK_PROGRESS(browser->progressBar), 0);
+}
+
+
+void
+net_state_change_cb (GeckoEmbed *embed, gint flags, guint status,
+		     TestGeckoBrowser *browser)
+{
+  g_print("net_state_change_cb %d\n", flags);
+  if (flags & GECKO_EMBED_FLAG_IS_REQUEST) {
+    if (flags & GECKO_EMBED_FLAG_REDIRECTING)
+    browser->statusMessage = "Redirecting to site...";
+    else if (flags & GECKO_EMBED_FLAG_TRANSFERRING)
+    browser->statusMessage = "Transferring data from site...";
+    else if (flags & GECKO_EMBED_FLAG_NEGOTIATING)
+    browser->statusMessage = "Waiting for authorization...";
+  }
+
+  if (status == GECKO_EMBED_STATUS_FAILED_DNS)
+    browser->statusMessage = "Site not found.";
+  else if (status == GECKO_EMBED_STATUS_FAILED_CONNECT)
+    browser->statusMessage = "Failed to connect to site.";
+  else if (status == GECKO_EMBED_STATUS_FAILED_TIMEOUT)
+    browser->statusMessage = "Failed due to connection timeout.";
+  else if (status == GECKO_EMBED_STATUS_FAILED_USERCANCELED)
+    browser->statusMessage = "User canceled connecting to site.";
+
+  if (flags & GECKO_EMBED_FLAG_IS_DOCUMENT) {
+    if (flags & GECKO_EMBED_FLAG_START)
+      browser->statusMessage = "Loading site...";
+    else if (flags & GECKO_EMBED_FLAG_STOP)
+      browser->statusMessage = "Done.";
+  }
+
+  update_status_bar_text(browser);
+  
+}
+
+void net_state_change_all_cb (GeckoEmbed *embed, const char *uri,
+				     gint flags, guint status,
+				     TestGeckoBrowser *browser)
+{
+  //  g_print("net_state_change_all_cb %s %d %d\n", uri, flags, status);
+}
+
+void progress_change_cb   (GeckoEmbed *embed, gint cur, gint max,
+			   TestGeckoBrowser *browser)
+{
+  g_print("progress_change_cb cur %d max %d\n", cur, max);
+
+  // avoid those pesky divide by zero errors
+  if (max < 1)
+  {
+    gtk_progress_set_activity_mode(GTK_PROGRESS(browser->progressBar), FALSE);
+    browser->loadPercent = 0;
+    browser->bytesLoaded = cur;
+    browser->maxBytesLoaded = 0;
+    update_status_bar_text(browser);
+  }
+  else
+  {
+    browser->bytesLoaded = cur;
+    browser->maxBytesLoaded = max;
+    if (cur > max)
+      browser->loadPercent = 100;
+    else
+      browser->loadPercent = (cur * 100) / max;
+    update_status_bar_text(browser);
+    gtk_progress_set_percentage(GTK_PROGRESS(browser->progressBar), browser->loadPercent / 100.0);
+  }
+  
+}
+
+void progress_change_all_cb (GeckoEmbed *embed, const char *uri,
+			     gint cur, gint max,
+			     TestGeckoBrowser *browser)
+{
+  //g_print("progress_change_all_cb %s cur %d max %d\n", uri, cur, max);
+}
+
+void
+link_message_cb      (GeckoEmbed *embed, TestGeckoBrowser *browser)
+{
+  char *message;
+  g_print("link_message_cb\n");
+  message = gecko_embed_get_link_message(embed);
+  if (!message || !*message)
+    update_temp_message(browser, 0);
+  else
+    update_temp_message(browser, message);
+  if (message)
+    g_free(message);
+}
+
+void
+js_status_cb (GeckoEmbed *embed, TestGeckoBrowser *browser)
+{
+ char *message;
+  g_print("js_status_cb\n");
+  message = gecko_embed_get_js_status(embed);
+  if (!message || !*message)
+    update_temp_message(browser, 0);
+  else
+    update_temp_message(browser, message);
+  if (message)
+    g_free(message);
+}
+
+void
+new_window_cb (GeckoEmbed *embed, GeckoEmbed **newEmbed, guint chromemask, TestGeckoBrowser *browser)
+{
+  g_print("new_window_cb\n");
+  g_print("embed is %p chromemask is %d\n", (void *)embed, chromemask);
+  TestGeckoBrowser *newBrowser = new_gecko_browser(chromemask);
+  gtk_widget_set_usize(newBrowser->mozEmbed, 400, 400);
+  *newEmbed = GECKO_EMBED(newBrowser->mozEmbed);
+  g_print("new browser is %p\n", (void *)*newEmbed);
+}
+
+void
+visibility_cb (GeckoEmbed *embed, gboolean visibility, TestGeckoBrowser *browser)
+{
+  g_print("visibility_cb %d\n", visibility);
+  set_browser_visibility(browser, visibility);
+}
+
+void
+destroy_brsr_cb      (GeckoEmbed *embed, TestGeckoBrowser *browser)
+{
+  g_print("destroy_brsr_cb\n");
+  gtk_widget_destroy(browser->topLevelWindow);
+}
+
+gint
+open_uri_cb          (GeckoEmbed *embed, const char *uri, TestGeckoBrowser *browser)
+{
+  g_print("open_uri_cb %s\n", uri);
+
+  // interrupt this test load
+  if (!strcmp(uri, "http://people.redhat.com/blizzard/monkeys.txt"))
+    return TRUE;
+  // don't interrupt anything
+  return FALSE;
+}
+
+void
+size_to_cb (GeckoEmbed *embed, gint width, gint height,
+	    TestGeckoBrowser *browser)
+{
+  g_print("*** size_to_cb %d %d\n", width, height);
+  gtk_widget_set_usize(browser->mozEmbed, width, height);
+}
+
+gboolean dom_key_down_cb      (GeckoEmbed *embed,
+			   GeckoDOMEvent *gecko_event,
+			   TestGeckoBrowser *browser)
+{
+  nsIDOMEvent *domevent = gecko_dom_event_get_I (gecko_event);
+  nsCOMPtr<nsIDOMKeyEvent> event (do_QueryInterface (domevent));
+
+  PRUint32 keyCode = 0;
+  //  g_print("dom_key_down_cb\n");
+  event->GetKeyCode(&keyCode);
+  // g_print("key code is %d\n", keyCode);
+  return NS_OK;
+}
+
+gboolean dom_key_press_cb     (GeckoEmbed *embed,
+			   GeckoDOMEvent *gecko_event,
+			   TestGeckoBrowser *browser)
+{
+  nsIDOMEvent *domevent = gecko_dom_event_get_I (gecko_event);
+  nsCOMPtr<nsIDOMKeyEvent> event (do_QueryInterface (domevent));
+
+  PRUint32 keyCode = 0;
+  // g_print("dom_key_press_cb\n");
+  event->GetCharCode(&keyCode);
+  // g_print("char code is %d\n", keyCode);
+  return NS_OK;
+}
+
+gboolean dom_key_up_cb        (GeckoEmbed *embed, 
+			   GeckoDOMEvent *gecko_event,
+			   TestGeckoBrowser *browser)
+{
+  nsIDOMEvent *domevent = gecko_dom_event_get_I (gecko_event);
+  nsCOMPtr<nsIDOMKeyEvent> event (do_QueryInterface (domevent));
+
+  PRUint32 keyCode = 0;
+  // g_print("dom_key_up_cb\n");
+  event->GetKeyCode(&keyCode);
+  // g_print("key code is %d\n", keyCode);
+  return NS_OK;
+}
+
+gboolean dom_mouse_down_cb    (GeckoEmbed *embed, 
+			   GeckoDOMEvent *gecko_event,
+			   TestGeckoBrowser *browser)
+{
+  //  g_print("dom_mouse_down_cb\n");
+  return NS_OK;
+ }
+
+gboolean dom_mouse_up_cb      (GeckoEmbed *embed, 
+			   GeckoDOMEvent *gecko_event,
+			   TestGeckoBrowser *browser)
+{
+  //  g_print("dom_mouse_up_cb\n");
+  return NS_OK;
+}
+
+gboolean dom_mouse_click_cb   (GeckoEmbed *embed,
+			   GeckoDOMEvent *gecko_event,
+			   TestGeckoBrowser *browser)
+{
+  nsIDOMEvent *domevent = gecko_dom_event_get_I (gecko_event);
+  nsCOMPtr<nsIDOMMouseEvent> event (do_QueryInterface (domevent));
+
+  //  g_print("dom_mouse_click_cb\n");
+  PRUint16 button;
+  event->GetButton(&button);
+  printf("button was %d\n", button);
+  return NS_OK;
+}
+
+gboolean dom_mouse_dbl_click_cb (GeckoEmbed *embed, 
+			     GeckoDOMEvent *gecko_event,
+			     TestGeckoBrowser *browser)
+{
+  //  g_print("dom_mouse_dbl_click_cb\n");
+  return NS_OK;
+}
+
+gboolean dom_mouse_over_cb    (GeckoEmbed *embed, 
+			   GeckoDOMEvent *gecko_event,
+			   TestGeckoBrowser *browser)
+{
+  //g_print("dom_mouse_over_cb\n");
+  return NS_OK;
+}
+
+gboolean dom_mouse_out_cb     (GeckoEmbed *embed, 
+			   GeckoDOMEvent *gecko_event,
+			   TestGeckoBrowser *browser)
+{
+  //g_print("dom_mouse_out_cb\n");
+  return NS_OK;
+}
+
+gboolean dom_activate_cb      (GeckoEmbed *embed,
+			   GeckoDOMEvent *gecko_event,
+			   TestGeckoBrowser *browser)
+{
+  //g_print("dom_activate_cb\n");
+  return NS_OK;
+}
+
+gboolean dom_focus_in_cb      (GeckoEmbed *embed, 
+			   GeckoDOMEvent *gecko_event,
+			   TestGeckoBrowser *browser)
+{
+  //g_print("dom_focus_in_cb\n");
+  return NS_OK;
+}
+
+gboolean dom_focus_out_cb     (GeckoEmbed *embed, 
+			   GeckoDOMEvent *gecko_event,
+			   TestGeckoBrowser *browser)
+{
+  //g_print("dom_focus_out_cb\n");
+  return NS_OK;
+}
+
+gboolean dom_context_menu_cb     (GeckoEmbed *embed, 
+			   GeckoDOMEvent *gecko_event,
+			   TestGeckoBrowser *browser)
+{
+  g_print("dom_context_menu_cb\n");
+  return NS_OK;
+}
+
+void new_window_orphan_cb (GeckoEmbedSingle *embed,
+			   GeckoEmbed **retval, guint chromemask,
+			   gpointer data)
+{
+  g_print("new_window_orphan_cb\n");
+  g_print("chromemask is %d\n", chromemask);
+  TestGeckoBrowser *newBrowser = new_gecko_browser(chromemask);
+  *retval = GECKO_EMBED(newBrowser->mozEmbed);
+  g_print("new browser is %p\n", (void *)*retval);
+}
+
+// utility functions
+
+void
+update_status_bar_text(TestGeckoBrowser *browser)
+{
+  gchar message[256];
+  
+  gtk_statusbar_pop(GTK_STATUSBAR(browser->statusBar), 1);
+  if (browser->tempMessage)
+    gtk_statusbar_push(GTK_STATUSBAR(browser->statusBar), 1, browser->tempMessage);
+  else
+  {
+    if (browser->loadPercent)
+    {
+      g_snprintf(message, 255, "%s (%d%% complete, %d bytes of %d loaded)", browser->statusMessage, browser->loadPercent, browser->bytesLoaded, browser->maxBytesLoaded);
+    }
+    else if (browser->bytesLoaded)
+    {
+      g_snprintf(message, 255, "%s (%d bytes loaded)", browser->statusMessage, browser->bytesLoaded);
+    }
+    else if (browser->statusMessage == NULL)
+    {
+      g_snprintf(message, 255, " ");
+    }
+    else
+    {
+      g_snprintf(message, 255, "%s", browser->statusMessage);
+    }
+    gtk_statusbar_push(GTK_STATUSBAR(browser->statusBar), 1, message);
+  }
+}
+
+void
+update_temp_message(TestGeckoBrowser *browser, const char *message)
+{
+  if (browser->tempMessage)
+    g_free(browser->tempMessage);
+  if (message)
+    browser->tempMessage = g_strdup(message);
+  else
+    browser->tempMessage = 0;
+  // now that we've updated the temp message, redraw the status bar
+  update_status_bar_text(browser);
+}
+
+
+void
+update_nav_buttons      (TestGeckoBrowser *browser)
+{
+  gboolean can_go_back;
+  gboolean can_go_forward;
+  can_go_back = gecko_embed_can_go_back(GECKO_EMBED(browser->mozEmbed));
+  can_go_forward = gecko_embed_can_go_forward(GECKO_EMBED(browser->mozEmbed));
+  if (can_go_back)
+    gtk_widget_set_sensitive(browser->backButton, TRUE);
+  else
+    gtk_widget_set_sensitive(browser->backButton, FALSE);
+  if (can_go_forward)
+    gtk_widget_set_sensitive(browser->forwardButton, TRUE);
+  else
+    gtk_widget_set_sensitive(browser->forwardButton, FALSE);
+ }