BrowserWindow.cpp

Go to the documentation of this file.

/*

$Id$

*/

#include <gtk/gtk.h>
#include <math.h>

#include <nsCOMPtr.h>
#include <nsStringAPI.h>
#include <nsIDOMDocument.h>
#include <nsIDOMWindowInternal.h>
#include <nsIWebBrowser.h>
#include <nsIScrollable.h>

#include "Error.h"

#include "BrowserWindow.h"

// Public methods.

BrowserWindow::BrowserWindow(const String &profilePath, const unsigned int chromeMask) : Object(),
  _topLevelWindow(NULL),
  _topLevelVBox(NULL),
  _mozEmbed(NULL),
  _progressAreaHBox(NULL),
  _statusAlign(NULL),
  _statusBar(NULL),
  _progressAlign(NULL),
  _progressBar(NULL),
  _statusBarVisible(true),
  _progressBarVisible(true),
  _progressBarAutoMode(false),
  _status()
{
  gtk_moz_embed_set_profile_path(CSTRING(profilePath), ".");

  if (!(_topLevelWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL))) {
    failure(ERROR(MSG_OBJECT_CANNOT_CREATE, "GtkWindow"));
    return;
  }

  _topLevelVBox = gtk_vbox_new(FALSE, 0);
  gtk_container_add(GTK_CONTAINER(_topLevelWindow), _topLevelVBox);

  if (!(_mozEmbed = gtk_moz_embed_new())) {
    failure(ERROR(MSG_OBJECT_CANNOT_CREATE, "GtkMozEmbed"));
    return;
  }
  gtk_box_pack_start(GTK_BOX(_topLevelVBox), _mozEmbed, TRUE, TRUE, 0);

  _progressAreaHBox = gtk_hbox_new(FALSE, 0);
  gtk_box_pack_start(GTK_BOX(_topLevelVBox), _progressAreaHBox, FALSE, FALSE, 0);

  _statusAlign = gtk_alignment_new(0, 0, 1, 1);
  gtk_widget_set_usize(_statusAlign, 1, -1);
  _statusBar = gtk_statusbar_new();
  gtk_statusbar_set_has_resize_grip(GTK_STATUSBAR(_statusBar), FALSE);
  gtk_container_add(GTK_CONTAINER(_statusAlign), _statusBar);
  gtk_box_pack_start(GTK_BOX(_progressAreaHBox), _statusAlign, TRUE, TRUE, 0);

  _progressAlign = gtk_alignment_new(1, 0, 1, 1);
  gtk_widget_set_usize(_progressAlign, -1, -1);
  _progressBar = gtk_progress_bar_new();
  gtk_container_add(GTK_CONTAINER(_progressAlign), _progressBar);
  gtk_box_pack_start(GTK_BOX(_progressAreaHBox), _progressAlign, FALSE, FALSE, 0);

  // Catch the destruction of the toplevel window.
  gtk_signal_connect(GTK_OBJECT(_topLevelWindow), "delete_event", GTK_SIGNAL_FUNC(BrowserWindow::_onDelete), this);
  // Hook up the location change.
  gtk_signal_connect(GTK_OBJECT(_mozEmbed), "location", GTK_SIGNAL_FUNC(BrowserWindow::_onLocationChanged), this);
  // Hook up the title change to update the window title.
  gtk_signal_connect(GTK_OBJECT(_mozEmbed), "title", GTK_SIGNAL_FUNC(BrowserWindow::_onTitleChanged), this);
  // Hook up the start and stop signals.
  gtk_signal_connect(GTK_OBJECT(_mozEmbed), "net_start", GTK_SIGNAL_FUNC(BrowserWindow::_onLoadStarted), this);
  gtk_signal_connect(GTK_OBJECT(_mozEmbed), "net_stop", GTK_SIGNAL_FUNC(BrowserWindow::_onLoadFinished), this);
  // Hook up to the change in network status.
  gtk_signal_connect(GTK_OBJECT(_mozEmbed), "net_state", GTK_SIGNAL_FUNC(BrowserWindow::_onNetStateChange), this);
  gtk_signal_connect(GTK_OBJECT(_mozEmbed), "net_state_all", GTK_SIGNAL_FUNC(BrowserWindow::_onNetStateChangeAll), this);
  // Hookup to changes in progress.
  gtk_signal_connect(GTK_OBJECT(_mozEmbed), "progress", GTK_SIGNAL_FUNC(BrowserWindow::_onProgressChange), this);
  gtk_signal_connect(GTK_OBJECT(_mozEmbed), "progress_all", GTK_SIGNAL_FUNC(BrowserWindow::_onProgressChangeAll), this);
  // Hookup to changes in over-link message.
  gtk_signal_connect(GTK_OBJECT(_mozEmbed), "link_message", GTK_SIGNAL_FUNC(BrowserWindow::_onLinkMessage), this);
  // Hookup to changes in js status message.
  gtk_signal_connect(GTK_OBJECT(_mozEmbed), "js_status", GTK_SIGNAL_FUNC(BrowserWindow::_onJSStatus), this);
  // Hookup to see whenever a new window is requested.
  gtk_signal_connect(GTK_OBJECT(_mozEmbed), "new_window", GTK_SIGNAL_FUNC(BrowserWindow::_onNewWindow), this);
  // Hookup to any requested visibility changes.
  gtk_signal_connect(GTK_OBJECT(_mozEmbed), "visibility", GTK_SIGNAL_FUNC(BrowserWindow::_onVisibility), this);
  // Hookup to the signal that says that the browser requested to be destroyed.
  gtk_signal_connect(GTK_OBJECT(_mozEmbed), "destroy_browser", GTK_SIGNAL_FUNC(BrowserWindow::_onDestroyBrowser), this);
  // Hookup to the signal that is called when someone clicks on a link to load a new uri.
  gtk_signal_connect(GTK_OBJECT(_mozEmbed), "open_uri", GTK_SIGNAL_FUNC(BrowserWindow::_onOpenUri), this);
  // 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(_mozEmbed), "size_to", GTK_SIGNAL_FUNC(BrowserWindow::_onSizeTo), this);

  // Keys and mouse event signals.
  gtk_signal_connect(GTK_OBJECT(_mozEmbed), "dom_key_down", GTK_SIGNAL_FUNC(BrowserWindow::_onKeyDown), this);
  gtk_signal_connect(GTK_OBJECT(_mozEmbed), "dom_key_press", GTK_SIGNAL_FUNC(BrowserWindow::_onKeyPress), this);
  gtk_signal_connect(GTK_OBJECT(_mozEmbed), "dom_key_up", GTK_SIGNAL_FUNC(BrowserWindow::_onKeyUp), this);
  gtk_signal_connect(GTK_OBJECT(_mozEmbed), "dom_mouse_down", GTK_SIGNAL_FUNC(BrowserWindow::_onMouseDown), this);
  gtk_signal_connect(GTK_OBJECT(_mozEmbed), "dom_mouse_up", GTK_SIGNAL_FUNC(BrowserWindow::_onMouseUp), this);
  gtk_signal_connect(GTK_OBJECT(_mozEmbed), "dom_mouse_click", GTK_SIGNAL_FUNC(BrowserWindow::_onMouseClick), this);
  gtk_signal_connect(GTK_OBJECT(_mozEmbed), "dom_mouse_dbl_click", GTK_SIGNAL_FUNC(BrowserWindow::_onMouseDoubleClick), this);
  gtk_signal_connect(GTK_OBJECT(_mozEmbed), "dom_mouse_over", GTK_SIGNAL_FUNC(BrowserWindow::_onMouseOver), this);
  gtk_signal_connect(GTK_OBJECT(_mozEmbed), "dom_mouse_out", GTK_SIGNAL_FUNC(BrowserWindow::_onMouseOut), this);

  gtk_signal_connect(GTK_OBJECT(_mozEmbed), "security_change", GTK_SIGNAL_FUNC(BrowserWindow::_onSecurityChange), this);

  gtk_signal_connect(GTK_OBJECT(_mozEmbed), "dom_activate", GTK_SIGNAL_FUNC(BrowserWindow::_onActivate), this);
  gtk_signal_connect(GTK_OBJECT(_mozEmbed), "dom_focus_in", GTK_SIGNAL_FUNC(BrowserWindow::_onFocusIn), this);
  gtk_signal_connect(GTK_OBJECT(_mozEmbed), "dom_focus_out", GTK_SIGNAL_FUNC(BrowserWindow::_onFocusOut), this);

  // Hookup to when the window is destroyed.
  gtk_signal_connect(GTK_OBJECT(_mozEmbed), "destroy", GTK_SIGNAL_FUNC(BrowserWindow::_onDestroy), this);

  // Set the chrome type so it's stored in the object.
  gtk_moz_embed_set_chrome_mask(GTK_MOZ_EMBED(_mozEmbed), chromeMask);

  // Get the singleton object and hook up to its new window callback
  // so we can create orphaned windows.
  GtkMozEmbedSingle *single;

  if (!(single = gtk_moz_embed_single_get())) {
    failure(ERROR(MSG_BROWSER_WINDOW_CANNOT_GET_SINGLETON_EMBED_OBJECT));
    return;
  }

  gtk_signal_connect(GTK_OBJECT(single), "new_window_orphan", GTK_SIGNAL_FUNC(BrowserWindow::_onNewWindowOrphan), this);
}

BrowserWindow::~BrowserWindow()
{
  gtk_widget_destroy(_topLevelWindow);
}

int BrowserWindow::mozillaWidget(GtkWidget **mozilla)
{
  *mozilla = _mozEmbed;
  return OK;
}

int BrowserWindow::setVisibility(const bool visible)
{
  int res;

  if (FAILED(res = visible ? show() : hide()))
    return ERROR_BACKTRACE(res);

  return OK;
}

int BrowserWindow::show()
{
  if (_statusBarVisible)
    gtk_widget_show_all(_statusAlign);
  if (_progressBarVisible)
    gtk_widget_show_all(_progressAlign);
  gtk_widget_show(_progressAreaHBox);
  gtk_widget_show(_mozEmbed);
  gtk_widget_show(_topLevelVBox);
  gtk_widget_show(_topLevelWindow);
  EMIT(shown);
  return OK;
}

int BrowserWindow::hide()
{
  gtk_widget_hide(_topLevelWindow);
  EMIT(hidden);
  return OK;
}

int BrowserWindow::setScrollBarsVisibility(const bool visible)
{
  nsCOMPtr<nsIWebBrowser> b;
  nsCOMPtr<nsIScrollable> scrollable;
  int res;

  if (FAILED(res = browser(getter_AddRefs(b))))
    return ERROR_BACKTRACE(res);

  if (!(scrollable = do_QueryInterface(b)))
    return ERROR(MSG_NO_INTERFACE, "nsIScrollable");

  scrollable->SetDefaultScrollbarPreferences((PRInt32)nsIScrollable::ScrollOrientation_X,
                                             visible ? (PRInt32)nsIScrollable::Scrollbar_Auto : (PRInt32)nsIScrollable::Scrollbar_Never);
  scrollable->SetDefaultScrollbarPreferences((PRInt32)nsIScrollable::ScrollOrientation_Y,
                                             visible ? (PRInt32)nsIScrollable::Scrollbar_Auto : (PRInt32)nsIScrollable::Scrollbar_Never);

  return OK;
}

int BrowserWindow::setStatusBarVisibility(const bool visible)
{
  int res;

  if (FAILED(res = visible ? showStatusBar() : hideStatusBar()))
    return ERROR_BACKTRACE(res);

  return OK;
}

int BrowserWindow::showStatusBar()
{
  gtk_widget_show_all(_statusAlign);
  gtk_widget_show(_progressAreaHBox);
  gtk_box_set_child_packing(GTK_BOX(_progressAreaHBox), _progressAlign, FALSE, FALSE, 0, GTK_PACK_START);
  _statusBarVisible = true;
  return OK;
}

int BrowserWindow::hideStatusBar()
{
  gtk_widget_hide_all(_statusAlign);
  gtk_box_set_child_packing(GTK_BOX(_progressAreaHBox), _progressAlign, TRUE, TRUE, 0, GTK_PACK_START);
  if (!_progressBarVisible)
    gtk_widget_hide(_progressAreaHBox);
  _statusBarVisible = false;
  return OK;
}

int BrowserWindow::setProgressBarVisibility(const bool visible)
{
  int res;

  if (FAILED(res = visible ? showProgressBar() : hideProgressBar()))
    return ERROR_BACKTRACE(res);

  return OK;
}

int BrowserWindow::showProgressBar()
{
  gtk_widget_show_all(_progressBar);
  gtk_widget_show(_progressAreaHBox);
  _progressBarVisible = true;
  return OK;
}

int BrowserWindow::hideProgressBar()
{
  gtk_widget_hide_all(_progressBar);
  if (!_statusBarVisible)
    gtk_widget_hide(_progressAreaHBox);
  _progressBarVisible = false;
  return OK;
}

int BrowserWindow::setProgressBarAutoMode(const bool enabled)
{
  _progressBarAutoMode = enabled;
  return OK;
}

int BrowserWindow::size(int &width, int &height)
{
  gdk_window_get_size(_topLevelWindow->window, &width, &height);
  return OK;
}

int BrowserWindow::setSize(const int width, const int height)
{
  int w, h;

  gdk_window_get_size(_topLevelWindow->window, &w, &h);
  if (width > 0)
    w = width;
  if (height > 0)
    h = height;
  gdk_window_resize(_topLevelWindow->window, w, h);
  return OK;
}

int BrowserWindow::position(int &x, int &y)
{
  gdk_window_get_position(_topLevelWindow->window, &x, &y);
  return OK;
}

int BrowserWindow::setPos(const int x, const int y)
{
  gdk_window_move(_topLevelWindow->window, x, y);
  return OK;
}

int BrowserWindow::setXPos(const int x)
{
  int xPos, yPos;

  gdk_window_get_position(_topLevelWindow->window, &xPos, &yPos);
  gdk_window_move(_topLevelWindow->window, x, yPos);
  return OK;
}

int BrowserWindow::setYPos(const int y)
{
  int xPos, yPos;

  gdk_window_get_position(_topLevelWindow->window, &xPos, &yPos);
  gdk_window_move(_topLevelWindow->window, xPos, y);
  return OK;
}

int BrowserWindow::textScale(unsigned int &scale)
{
  nsCOMPtr<nsIDOMWindow> domWindow;
  nsresult res;
  float s;

  if (FAILED(res = topDomWindow(getter_AddRefs(domWindow))))
    return ERROR_BACKTRACE(res);

  if (NS_FAILED(res = domWindow->GetTextZoom(&s)))
    return ERROR_BACKTRACE(res);

  scale = (int)round(s * 100.0f);

  return OK;
}

int BrowserWindow::setTextScale(const unsigned int scale)
{
  nsCOMPtr<nsIDOMWindow> domWindow;
  nsresult res;

  DEBUG("Setting text scale to %f.", (double)scale / 100.0f);

  if (FAILED(res = topDomWindow(getter_AddRefs(domWindow))))
    return ERROR_BACKTRACE(res);

  if (NS_FAILED(res = domWindow->SetTextZoom((double)scale / 100.0f)))
    return ERROR_BACKTRACE(res);

  return OK;
}

int BrowserWindow::load(const String& url)
{
  DEBUG("Loading URL '%s'.", CSTRING(url));
  gtk_moz_embed_load_url(GTK_MOZ_EMBED(_mozEmbed), CSTRING(url));

  return OK;
}

int BrowserWindow::close()
{
  int res;
  if (FAILED(res = onDelete()))
    return ERROR_BACKTRACE(res);
  return OK;
}

int BrowserWindow::focus()
{
  nsCOMPtr<nsIDOMWindow> domWindow;
  nsCOMPtr<nsIDOMWindowInternal> domWindowInternal;
  nsresult res;

  if (FAILED(res = topDomWindow(getter_AddRefs(domWindow))))
    return ERROR_BACKTRACE(res);

  if (!(domWindowInternal = do_QueryInterface(domWindow)))
    return ERROR(MSG_NO_INTERFACE, "nsIDOMWindowInternal");

  if (NS_FAILED(res = domWindowInternal->Focus()))
    return ERROR_BACKTRACE(res);
  return OK;
}

int BrowserWindow::stop()
{
  gtk_moz_embed_stop_load(GTK_MOZ_EMBED(_mozEmbed));
  return OK;
}

int BrowserWindow::canGoBack(bool &yes)
{
  yes = gtk_moz_embed_can_go_back(GTK_MOZ_EMBED(_mozEmbed));
  return OK;
}

int BrowserWindow::back()
{
  gtk_moz_embed_go_back(GTK_MOZ_EMBED(_mozEmbed));
  return OK;
}

int BrowserWindow::canGoForward(bool &yes)
{
  yes = gtk_moz_embed_can_go_forward(GTK_MOZ_EMBED(_mozEmbed));
  return OK;
}

int BrowserWindow::forward()
{
  gtk_moz_embed_go_forward(GTK_MOZ_EMBED(_mozEmbed));
  return OK;
}

int BrowserWindow::reload(const bool useCache)
{
  gtk_moz_embed_reload(GTK_MOZ_EMBED(_mozEmbed),
    useCache ? GTK_MOZ_EMBED_FLAG_RELOADNORMAL : GTK_MOZ_EMBED_FLAG_RELOADBYPASSCACHE);
  return OK;
}

String BrowserWindow::status() const
{
  return _status.message;
}

int BrowserWindow::loadPercent() const
{
  return _status.loadPercent;
}

int BrowserWindow::bytesLoaded() const
{
  return _status.bytesLoaded;
}

int BrowserWindow::maxBytesLoaded() const
{
  return _status.maxBytesLoaded;
}

bool BrowserWindow::loadFinished() const
{
  return _status.loadFinished;
}

int BrowserWindow::renderData(const String &data)
{
  gtk_moz_embed_open_stream(GTK_MOZ_EMBED(_mozEmbed), "file://", "text/html");
  gtk_moz_embed_append_data(GTK_MOZ_EMBED(_mozEmbed), CSTRING(data), data.length());
  gtk_moz_embed_close_stream(GTK_MOZ_EMBED(_mozEmbed));
  return OK;
}

// Protected methods.

int BrowserWindow::onDelete()
{
  int res;
  if (FAILED(res = hide()))
    return ERROR_BACKTRACE(res);
  EMIT(closed);
  return OK;
}

int BrowserWindow::onDestroy()
{
  return OK;
}

int BrowserWindow::onLocationChanged(const String &newLocation)
{
  return OK;
}

int BrowserWindow::onTitleChanged(const String &newTitle)
{
  gtk_window_set_title(GTK_WINDOW(_topLevelWindow), CSTRING(newTitle));
  return OK;
}

int BrowserWindow::onLoadStarted()
{
  int res;
  DEBUG("Document loading started.");
  _status.loadPercent = 0;
  _status.bytesLoaded = 0;
  _status.maxBytesLoaded = 0;
  _status.loadFinished = false;
  if (FAILED(res = updateStatusBar()))
    return ERROR_BACKTRACE(res);
  EMIT(started);
  return OK;
}

int BrowserWindow::onLoadFinished()
{
  int res;

  DEBUG("Document loading finished.");
  _status.loadPercent = 0;
  _status.bytesLoaded = 0;
  _status.maxBytesLoaded = 0;
  _status.loadFinished = true;

  if (FAILED(res = updateStatusBar()))
    return ERROR_BACKTRACE(res);

  gtk_progress_set_percentage(GTK_PROGRESS(_progressBar), 0);

  if (_progressBarAutoMode)
    if (FAILED(res = hideProgressBar()))
      return ERROR_BACKTRACE(res);

  EMIT(finished);

  return OK;
}

int BrowserWindow::onNetStateChange(const int flags, const unsigned int status)
{
  int res;

  if (flags & GTK_MOZ_EMBED_FLAG_IS_REQUEST)
    if (flags & GTK_MOZ_EMBED_FLAG_REDIRECTING)
      _status.message = "Redirecting to site...";
    else
      if (flags & GTK_MOZ_EMBED_FLAG_TRANSFERRING)
        _status.message = "Transferring data from site...";
      else
        if (flags & GTK_MOZ_EMBED_FLAG_NEGOTIATING)
          _status.message = "Waiting for authorization...";

  if (status == GTK_MOZ_EMBED_STATUS_FAILED_DNS)
    _status.message = "Site not found.";
  else
    if (status == GTK_MOZ_EMBED_STATUS_FAILED_CONNECT)
      _status.message = "Failed to connect to site.";
    else
      if (status == GTK_MOZ_EMBED_STATUS_FAILED_TIMEOUT)
        _status.message = "Failed due to connection timeout.";
      else
        if (status == GTK_MOZ_EMBED_STATUS_FAILED_USERCANCELED)
          _status.message = "User canceled connecting to site.";

  if (flags & GTK_MOZ_EMBED_FLAG_IS_DOCUMENT)
    if (flags & GTK_MOZ_EMBED_FLAG_START)
      _status.message = "Loading site...";
    else
      if (flags & GTK_MOZ_EMBED_FLAG_STOP)
        _status.message = "Done.";

  if (FAILED(res = updateStatusBar()))
    return ERROR_BACKTRACE(res);

  return OK;
}

int BrowserWindow::onNetStateChangeAll(const char *uri, const int flags, unsigned int status)
{
  return OK;
}

int BrowserWindow::onProgressChange(const int cur, const int max)
{
  int res;
  if (max < 1) {
    gtk_progress_set_activity_mode(GTK_PROGRESS(_progressBar), FALSE);
    _status.loadPercent = 0;
    _status.bytesLoaded = cur;
    _status.maxBytesLoaded = 0;
    if (_progressBarAutoMode)
      if (FAILED(res = hideProgressBar()))
        return ERROR_BACKTRACE(res);
  } else {
      _status.bytesLoaded = cur;
      _status.maxBytesLoaded = max;
      if (cur > max)
        _status.loadPercent = 100;
      else
        _status.loadPercent = (cur * 100) / max;
      if (_progressBarAutoMode && !_progressBarVisible)
        if (FAILED(res = showProgressBar()))
          return ERROR_BACKTRACE(res);
      gtk_progress_set_percentage(GTK_PROGRESS(_progressBar), _status.loadPercent / 100.0);
    }
  if (FAILED(res = updateStatusBar()))
    return ERROR_BACKTRACE(res);
  return OK;
}

int BrowserWindow::onProgressChangeAll(const char *uri, const int cur, const int max)
{
  return OK;
}

int BrowserWindow::onLinkMessage(const String &message)
{
  int res;
  _status.tempMessage = message;
  if (FAILED(res = updateStatusBar()))
    return ERROR_BACKTRACE(res);
  return OK;
}

int BrowserWindow::onJSStatus(const String &message)
{
  _status.tempMessage = message;
  return OK;
}

int BrowserWindow::onNewWindow(const unsigned int chromeMask, BrowserWindow **newBrowser)
{
  if (!(*newBrowser = newWindow(chromeMask)))
    return ERROR(MSG_NULL_POINTER);
  return OK;
}

int BrowserWindow::onVisibility(const bool visibility)
{
  int res;
  if (FAILED(res = setVisibility(visibility)))
    return ERROR_BACKTRACE(res);
  return OK;
}

int BrowserWindow::onDestroyBrowser()
{
  int res;
  if (FAILED(res = close()))
    return ERROR_BACKTRACE(res);
  return OK;
}

int BrowserWindow::onOpenUri(const char *uri, bool &interrupt)
{
  interrupt = false;
  return OK;
}

int BrowserWindow::onSizeTo(const int width, const int height)
{
  gtk_widget_set_usize(_mozEmbed, width, height);
  return OK;
}

int BrowserWindow::onKeyDown(nsIDOMKeyEvent *event)
{
  return OK;
}

int BrowserWindow::onKeyPress(nsIDOMKeyEvent *event)
{
  return OK;
}

int BrowserWindow::onKeyUp(nsIDOMKeyEvent *event)
{
  return OK;
}

int BrowserWindow::onMouseDown(nsIDOMMouseEvent *event)
{
  return OK;
}

int BrowserWindow::onMouseUp(nsIDOMMouseEvent *event)
{
  return OK;
}

int BrowserWindow::onMouseClick(nsIDOMMouseEvent *event)
{
  return OK;
}

int BrowserWindow::onMouseDoubleClick(nsIDOMMouseEvent *event)
{
  return OK;
}

int BrowserWindow::onMouseOver(nsIDOMMouseEvent *event)
{
  return OK;
}

int BrowserWindow::onMouseOut(nsIDOMMouseEvent *event)
{
  return OK;
}

int BrowserWindow::onActivate(nsIDOMUIEvent *event)
{
  return OK;
}

int BrowserWindow::onFocusIn(nsIDOMUIEvent *event)
{
  return OK;
}

int BrowserWindow::onFocusOut(nsIDOMUIEvent *event)
{
  return OK;
}

BrowserWindow *BrowserWindow::newWindow(const unsigned int chromeMask)
{
  BrowserWindow *newBrowser = new BrowserWindow("", chromeMask);
  int res;

  if (!newBrowser) {
    ERROR(MSG_OBJECT_CANNOT_CREATE, "BrowserWindow");
    return NULL;
  }
  if (FAILED(res = newBrowser->failureCode())) {
    ERROR_BACKTRACE(res);
    delete newBrowser;
    return NULL;
  }
  return newBrowser;
}

// Private methods.

int BrowserWindow::browser(nsIWebBrowser **webBrowser)
{
  nsCOMPtr<nsIWebBrowser> b;

  gtk_moz_embed_get_nsIWebBrowser(GTK_MOZ_EMBED(_mozEmbed), getter_AddRefs(b));
  if (!b)
    return ERROR(MSG_NULL_POINTER);
  *webBrowser = b;
  NS_ADDREF(*webBrowser);

  return OK;
}

int BrowserWindow::topDomWindow(nsIDOMWindow **window)
{
  nsCOMPtr<nsIWebBrowser> b;
  nsCOMPtr<nsIDOMWindow> domWindow;
  nsresult res;

  if (FAILED(res = browser(getter_AddRefs(b))))
    return ERROR_BACKTRACE(res);

  if (NS_FAILED(res = b->GetContentDOMWindow(getter_AddRefs(domWindow))))
    return ERROR_BACKTRACE(res);

  *window = domWindow;
  NS_ADDREF(*window);

  return OK;
}

// Event handlers.

gboolean BrowserWindow::_onDelete(GtkWidget *widget, GdkEventAny *event, BrowserWindow *browser)
{
  int res;
  if (FAILED(res = browser->onDelete())) {
    ERROR_BACKTRACE(res);
    return FALSE;
  }
  return TRUE;
}

void BrowserWindow::_onDestroy(GtkWidget *widget, BrowserWindow *browser)
{
  int res;
  if (FAILED(res = browser->onDestroy()))
    ERROR_BACKTRACE(res);
}

void BrowserWindow::_onLocationChanged(GtkMozEmbed *embed, BrowserWindow *browser)
{
  char *newLocation = gtk_moz_embed_get_location(embed);
  int res;

  if (newLocation) {
    if (FAILED(res = browser->onLocationChanged(newLocation)))
      ERROR_BACKTRACE(res);
    g_free(newLocation);
  } else
      ERROR(MSG_BROWSER_WINDOW_LOCATION_CANNOT_GET);
}

void BrowserWindow::_onTitleChanged(GtkMozEmbed *embed, BrowserWindow *browser)
{
  char *newTitle = gtk_moz_embed_get_title(embed);
  int res;

  if (FAILED(res = browser->onTitleChanged(newTitle)))
    ERROR_BACKTRACE(res);
  if (newTitle)
    g_free(newTitle);
}

void BrowserWindow::_onLoadStarted(GtkMozEmbed *embed, BrowserWindow *browser)
{
  int res;
  if (FAILED(res = browser->onLoadStarted()))
    ERROR_BACKTRACE(res);
}

void BrowserWindow::_onLoadFinished(GtkMozEmbed *embed, BrowserWindow *browser)
{
  int res;
  if (FAILED(res = browser->onLoadFinished()))
    ERROR_BACKTRACE(res);
}

void BrowserWindow::_onNetStateChange(GtkMozEmbed *embed, gint flags, guint status, BrowserWindow *browser)
{
  int res;
  if (FAILED(res = browser->onNetStateChange(flags, status)))
    ERROR_BACKTRACE(res);
}

void BrowserWindow::_onNetStateChangeAll(GtkMozEmbed *embed, const char *uri, gint flags, guint status, BrowserWindow *browser)
{
  int res;
  if (FAILED(res = browser->onNetStateChangeAll(uri, flags, status)))
    ERROR_BACKTRACE(res);
}

void BrowserWindow::_onProgressChange(GtkMozEmbed *embed, gint cur, gint max, BrowserWindow *browser)
{
  int res;
  if (FAILED(res = browser->onProgressChange(cur, max)))
    ERROR_BACKTRACE(res);
}

void BrowserWindow::_onProgressChangeAll(GtkMozEmbed *embed, const char *uri, gint cur, gint max, BrowserWindow *browser)
{
  int res;
  if (FAILED(res = browser->onProgressChangeAll(uri, cur, max)))
    ERROR_BACKTRACE(res);
}

void BrowserWindow::_onLinkMessage(GtkMozEmbed *embed, BrowserWindow *browser)
{
  char *message = gtk_moz_embed_get_link_message(embed);
  int res;
  if (FAILED(res = browser->onLinkMessage(message)))
    ERROR_BACKTRACE(res);
  if (message)
    g_free(message);
}

void BrowserWindow::_onJSStatus(GtkMozEmbed *embed, BrowserWindow *browser)
{
  char *message = gtk_moz_embed_get_js_status(embed);
  int res;
  if (FAILED(res = browser->onJSStatus(message)))
    ERROR_BACKTRACE(res);
  if (message)
    g_free(message);
}

void BrowserWindow::_onNewWindow(GtkMozEmbed *embed, GtkMozEmbed **newEmbed, guint chromeMask, BrowserWindow *browser)
{
  BrowserWindow *newBrowser;
  GtkWidget *mozilla;
  int res;

  *newEmbed = NULL;
  if (FAILED(res = browser->onNewWindow(chromeMask, &newBrowser))) {
    ERROR_BACKTRACE(res);
    return;
  }
  if (newBrowser) {
    if (FAILED(res = newBrowser->mozillaWidget(&mozilla))) {
      ERROR_BACKTRACE(res);
      return;
    }
    *newEmbed = GTK_MOZ_EMBED(mozilla);
  }
}

void BrowserWindow::_onVisibility(GtkMozEmbed *embed, gboolean visibility, BrowserWindow *browser)
{
  int res;
  if (FAILED(res = browser->onVisibility(visibility)))
    ERROR_BACKTRACE(res);
}

void BrowserWindow::_onDestroyBrowser(GtkMozEmbed *embed, BrowserWindow *browser)
{
  int res;
  if (FAILED(res = browser->onDestroyBrowser()))
    ERROR_BACKTRACE(res);
}

gint BrowserWindow::_onOpenUri(GtkMozEmbed *embed, const char *uri, BrowserWindow *browser)
{
  bool interrupt;
  int res;
  if (FAILED(res = browser->onOpenUri(uri, interrupt))) {
    ERROR_BACKTRACE(res);
    return TRUE;
  }
  return interrupt;
}

void BrowserWindow::_onSizeTo(GtkMozEmbed *embed, gint width, gint height, BrowserWindow *browser)
{
  int res;
  if (FAILED(res = browser->onSizeTo(width, height)))
    ERROR_BACKTRACE(res);
}

gint BrowserWindow::_onKeyDown(GtkMozEmbed *embed, nsIDOMKeyEvent *event, BrowserWindow *browser)
{
  int res;
  if (FAILED(res = browser->onKeyDown(event))) {
    ERROR_BACKTRACE(res);
    return NS_ERROR_FAILURE;
  }
  return NS_OK;
}

gint BrowserWindow::_onKeyPress(GtkMozEmbed *embed, nsIDOMKeyEvent *event, BrowserWindow *browser)
{
  int res;
  if (FAILED(res = browser->onKeyPress(event))) {
    ERROR_BACKTRACE(res);
    return NS_ERROR_FAILURE;
  }
  return NS_OK;
}

gint BrowserWindow::_onKeyUp(GtkMozEmbed *embed, nsIDOMKeyEvent *event, BrowserWindow *browser)
{
  int res;
  if (FAILED(res = browser->onKeyUp(event))) {
    ERROR_BACKTRACE(res);
    return NS_ERROR_FAILURE;
  }
  return NS_OK;
}

gint BrowserWindow::_onMouseDown(GtkMozEmbed *embed, nsIDOMMouseEvent *event, BrowserWindow *browser)
{
  int res;
  if (FAILED(res = browser->onMouseDown(event))) {
    ERROR_BACKTRACE(res);
    return NS_ERROR_FAILURE;
  }
  return NS_OK;
}

gint BrowserWindow::_onMouseUp(GtkMozEmbed *embed, nsIDOMMouseEvent *event, BrowserWindow *browser)
{
  int res;
  if (FAILED(res = browser->onMouseUp(event))) {
    ERROR_BACKTRACE(res);
    return NS_ERROR_FAILURE;
  }
  return NS_OK;
}

gint BrowserWindow::_onMouseClick(GtkMozEmbed *embed, nsIDOMMouseEvent *event, BrowserWindow *browser)
{
  int res;
  if (FAILED(res = browser->onMouseClick(event))) {
    ERROR_BACKTRACE(res);
    return NS_ERROR_FAILURE;
  }
  return NS_OK;
}

gint BrowserWindow::_onMouseDoubleClick(GtkMozEmbed *embed, nsIDOMMouseEvent *event, BrowserWindow *browser)
{
  int res;
  if (FAILED(res = browser->onMouseDoubleClick(event))) {
    ERROR_BACKTRACE(res);
    return NS_ERROR_FAILURE;
  }
  return NS_OK;
}

gint BrowserWindow::_onMouseOver(GtkMozEmbed *embed, nsIDOMMouseEvent *event, BrowserWindow *browser)
{
  int res;
  if (FAILED(res = browser->onMouseOver(event))) {
    ERROR_BACKTRACE(res);
    return NS_ERROR_FAILURE;
  }
  return NS_OK;
}

gint BrowserWindow::_onMouseOut(GtkMozEmbed *embed, nsIDOMMouseEvent *event, BrowserWindow *browser)
{
  int res;
  if (FAILED(res = browser->onMouseOut(event))) {
    ERROR_BACKTRACE(res);
    return NS_ERROR_FAILURE;
  }
  return NS_OK;
}

void BrowserWindow::_onSecurityChange(GtkMozEmbed *embed, gpointer request, guint state, BrowserWindow *browser)
{
}

gint BrowserWindow::_onActivate(GtkMozEmbed *embed, nsIDOMUIEvent *event, BrowserWindow *browser)
{
  int res;
  if (FAILED(res = browser->onActivate(event))) {
    ERROR_BACKTRACE(res);
    return NS_ERROR_FAILURE;
  }
  return NS_OK;
}

gint BrowserWindow::_onFocusIn(GtkMozEmbed *embed, nsIDOMUIEvent *event, BrowserWindow *browser)
{
  int res;
  if (FAILED(res = browser->onFocusIn(event))) {
    ERROR_BACKTRACE(res);
    return NS_ERROR_FAILURE;
  }
  return NS_OK;
}

gint BrowserWindow::_onFocusOut(GtkMozEmbed *embed, nsIDOMUIEvent *event, BrowserWindow *browser)
{
  int res;
  if (FAILED(res = browser->onFocusOut(event))) {
    ERROR_BACKTRACE(res);
    return NS_ERROR_FAILURE;
  }
  return NS_OK;
}

void BrowserWindow::_onNewWindowOrphan(GtkMozEmbedSingle *embed, GtkMozEmbed **newEmbed, guint chromeMask, BrowserWindow *browser)
{
  _onNewWindow(NULL, newEmbed, chromeMask, browser);
}

int BrowserWindow::updateStatusBar()
{
  gtk_statusbar_pop(GTK_STATUSBAR(_statusBar), 1);
  if (_status.tempMessage.empty()) {
    String message;

    if (_status.loadPercent)
      message.sprintf("%s (%d%% complete, %d bytes of %d loaded).", CSTRING(_status.message), _status.loadPercent, _status.bytesLoaded, _status.maxBytesLoaded);
    else
      if (_status.bytesLoaded)
        message.sprintf("%s (%d bytes loaded).", CSTRING(_status.message), _status.bytesLoaded);
      else
        message = _status.message;
    gtk_statusbar_push(GTK_STATUSBAR(_statusBar), 1, CSTRING(message));
  } else
      gtk_statusbar_push(GTK_STATUSBAR(_statusBar), 1, CSTRING(_status.tempMessage));
  return OK;
}

---