Porting the toolbar to GTK.

Quite a bit of TODOs in the code, but it displays and properly
enables/disables buttons and routes mouse clicks.

This also moves all the gtk files into the gtk/ folder, at Ben's request.

Review URL: http://codereview.chromium.org/21176


git-svn-id: svn://svn.chromium.org/chrome/trunk/src@9421 0039d316-1c4b-4281-b951-d872f2087c98

6 files changed, 573 insertions, 0 deletions

diff --git a/chrome/browser/gtk/browser_main_gtk.cc b/chrome/browser/gtk/browser_main_gtk.cc
new file mode 100644
index 0000000..b7e8360
--- /dev/null
+++ b/chrome/browser/gtk/browser_main_gtk.cc
@@ -0,0 +1,35 @@
+// Copyright (c) 2008 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "base/command_line.h"
+#include "chrome/app/result_codes.h"
+#include "chrome/browser/browser_main_win.h"
+
+// From browser_main_win.h, stubs until we figure out the right thing...
+
+int DoUninstallTasks() {
+  return ResultCodes::NORMAL_EXIT;
+}
+
+bool DoUpgradeTasks(const CommandLine& command_line) {
+  return ResultCodes::NORMAL_EXIT;
+}
+
+bool CheckForWin2000() {
+  return false;
+}
+
+int HandleIconsCommands(const CommandLine &parsed_command_line) {
+  return 0;
+}
+
+bool CheckMachineLevelInstall() {
+  return false;
+}
+
+void PrepareRestartOnCrashEnviroment(const CommandLine &parsed_command_line) {
+}
+
+void RecordBreakpadStatusUMA(MetricsService* metrics) {
+}
diff --git a/chrome/browser/gtk/browser_toolbar_view_gtk.cc b/chrome/browser/gtk/browser_toolbar_view_gtk.cc
new file mode 100644
index 0000000..00c28d7
--- /dev/null
+++ b/chrome/browser/gtk/browser_toolbar_view_gtk.cc
@@ -0,0 +1,144 @@
+// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "chrome/browser/gtk/browser_toolbar_view_gtk.h"
+
+#include "base/logging.h"
+#include "chrome/app/chrome_dll_resource.h"
+#include "chrome/browser/browser.h"
+#include "chrome/common/l10n_util.h"
+
+#include "chromium_strings.h"
+#include "generated_resources.h"
+
+BrowserToolbarGtk::BrowserToolbarGtk(Browser* browser)
+    : toolbar_(NULL),
+      back_(NULL),
+      forward_(NULL),
+      reload_(NULL),
+      home_(NULL),
+      star_(NULL),
+      model_(browser->toolbar_model()),
+      browser_(browser),
+      profile_(NULL) {
+  browser_->command_updater()->AddCommandObserver(IDC_BACK, this);
+  browser_->command_updater()->AddCommandObserver(IDC_FORWARD, this);
+  browser_->command_updater()->AddCommandObserver(IDC_RELOAD, this);
+  browser_->command_updater()->AddCommandObserver(IDC_HOME, this);
+  browser_->command_updater()->AddCommandObserver(IDC_STAR, this);
+
+  // TODO(port): Port BackForwardMenuModel
+  // back_menu_model_.reset(new BackForwardMenuModel(
+  //     browser, BackForwardMenuModel::BACKWARD_MENU_DELEGATE));
+  // forward_menu_model_.reset(new BackForwardMenuModel(
+  //     browser, BackForwardMenuModel::FORWARD_MENU_DELEGATE));
+}
+
+BrowserToolbarGtk::~BrowserToolbarGtk() {
+}
+
+void BrowserToolbarGtk::Init(Profile* profile) {
+  toolbar_ = gtk_hbox_new(FALSE, 0);
+  gtk_container_set_border_width(GTK_CONTAINER(toolbar_), 6);
+
+  toolbar_tooltips_ = gtk_tooltips_new();
+
+  back_ = BuildToolbarButton(l10n_util::GetString(IDS_TOOLTIP_BACK));
+  forward_ = BuildToolbarButton(l10n_util::GetString(IDS_TOOLTIP_FORWARD));
+  reload_ = BuildToolbarButton(l10n_util::GetString(IDS_TOOLTIP_RELOAD));
+  home_ = BuildToolbarButton(l10n_util::GetString(IDS_TOOLTIP_HOME));
+  star_ = BuildToolbarButton(l10n_util::GetString(IDS_TOOLTIP_STAR));
+
+  gtk_box_pack_start(GTK_BOX(toolbar_), gtk_label_new("  "), FALSE, FALSE, 0);
+  gtk_box_pack_start(GTK_BOX(toolbar_), gtk_entry_new(), TRUE, TRUE, 0);
+
+  go_ = BuildToolbarButton(L"");
+  page_menu_ = BuildToolbarButton(l10n_util::GetString(IDS_PAGEMENU_TOOLTIP));
+
+  // TODO(port): Need to get l10n_util::GetStringF working under linux to get
+  // the correct string here.
+  app_menu_ = BuildToolbarButton(l10n_util::GetString(IDS_APPMENU_TOOLTIP));
+
+  // TODO(erg): wchar_t mismatch on linux. Fix later.
+  //  show_home_button_.Init(prefs::kShowHomeButton, profile->GetPrefs(), this);
+
+  SetProfile(profile);
+}
+
+void BrowserToolbarGtk::AddToolbarToBox(GtkWidget* box) {
+  gtk_box_pack_start(GTK_BOX(box), toolbar_, FALSE, FALSE, 0);
+}
+
+void BrowserToolbarGtk::EnabledStateChangedForCommand(int id, bool enabled) {
+  GtkWidget* widget = NULL;
+  switch (id) {
+    case IDC_BACK:
+      widget = back_;
+      break;
+    case IDC_FORWARD:
+      widget = forward_;
+      break;
+    case IDC_RELOAD:
+      widget = reload_;
+      break;
+    case IDC_HOME:
+      widget = home_;
+      break;
+    case IDC_STAR:
+      widget = star_;
+      break;
+  }
+  if (widget)
+    gtk_widget_set_sensitive(widget, enabled);
+}
+
+void BrowserToolbarGtk::SetProfile(Profile* profile) {
+  if (profile == profile_)
+    return;
+
+  profile_ = profile;
+  // TODO(erg): location_bar_ is a normal gtk text box right now. Change this
+  // when we get omnibox support.
+  //  location_bar_->SetProfile(profile);
+}
+
+// TODO(port): This needs to deal with our styled pixmaps.
+GtkWidget* BrowserToolbarGtk::BuildToolbarButton(
+    const std::wstring& localized_tooltip) {
+  GtkWidget* b = gtk_button_new();
+  gtk_widget_set_size_request(b, 29, 29);
+
+  // TODO(erg): Mismatch between wstring and string.
+  // gtk_tooltips_set_tip(GTK_TOOLTIPS(toolbar_tooltips_),
+  //                      GTK_WIDGET(back_),
+  //                      localized_tooltip, localized_tooltip);
+  g_signal_connect(G_OBJECT(b), "clicked",
+                   G_CALLBACK(ButtonClickCallback), this);
+  gtk_box_pack_start(GTK_BOX(toolbar_), b, FALSE, FALSE, 0);
+
+  // TODO(erg): Change this when pixmap loading is working.
+  return b;
+}
+
+/* static */
+void BrowserToolbarGtk::ButtonClickCallback(GtkWidget* button,
+                                            BrowserToolbarGtk* toolbar) {
+  int tag = -1;
+  if (button == toolbar->back_)
+    tag = IDC_BACK;
+  else if (button == toolbar->forward_)
+    tag = IDC_FORWARD;
+  else if (button == toolbar->reload_)
+    tag = IDC_RELOAD;
+  else if (button == toolbar->home_)
+    tag = IDC_HOME;
+  else if (button == toolbar->star_)
+    tag = IDC_STAR;
+
+  if (tag != -1) {
+    toolbar->browser_->ExecuteCommand(tag);
+  } else {
+    // TODO(erg): The menu buttons are special; they need to spawn menus.
+  }
+}
diff --git a/chrome/browser/gtk/browser_toolbar_view_gtk.h b/chrome/browser/gtk/browser_toolbar_view_gtk.h
new file mode 100644
index 0000000..673bc10
--- /dev/null
+++ b/chrome/browser/gtk/browser_toolbar_view_gtk.h
@@ -0,0 +1,74 @@
+// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CHROME_BROWSER_BROWSER_TOOLBAR_VIEW_GTK_H_
+#define CHROME_BROWSER_BROWSER_TOOLBAR_VIEW_GTK_H_
+
+#include "chrome/browser/command_updater.h"
+#include "chrome/common/pref_member.h"
+
+#include <gtk/gtk.h>
+
+class Browser;
+class Profile;
+class ToolbarModel;
+
+// View class that displays the GTK version of the toolbar and routes gtk
+// events back to the Browser.
+class BrowserToolbarGtk : public CommandUpdater::CommandObserver {
+ public:
+  explicit BrowserToolbarGtk(Browser* browser);
+  virtual ~BrowserToolbarGtk();
+
+  // Create the contents of the toolbar
+  void Init(Profile* profile);
+
+  // Adds this GTK toolbar into a sizing box.
+  void AddToolbarToBox(GtkWidget* box);
+
+  // Overridden from CommandUpdater::CommandObserver:
+  virtual void EnabledStateChangedForCommand(int id, bool enabled);
+
+  void SetProfile(Profile* profile);
+
+ private:
+  // Builds a GtkButton with all the properties set.
+  GtkWidget* BuildToolbarButton(const std::wstring& localized_tooltip);
+
+  // Gtk callback for the "clicked" signal.
+  static void ButtonClickCallback(GtkWidget* button,
+                                  BrowserToolbarGtk* toolbar);
+
+  // Gtk widgets. The toolbar is an hbox with each of the other pieces of the
+  // toolbar placed side by side.
+  GtkWidget* toolbar_;
+
+  // Tooltip container for all GTK widgets in this class.
+  GtkTooltips* toolbar_tooltips_;
+
+  // All the GTK buttons in the toolbar.
+  GtkWidget* back_;
+  GtkWidget* forward_;
+  GtkWidget* reload_;
+  GtkWidget* home_;
+  GtkWidget* star_;
+  GtkWidget* go_;
+  GtkWidget* page_menu_;
+  GtkWidget* app_menu_;
+
+  // The model that contains the security level, text, icon to display...
+  ToolbarModel* model_;
+
+  // TODO(port): Port BackForwardMenuModel
+  // scoped_ptr<BackForwardMenuModel> back_menu_model_;
+  // scoped_ptr<BackForwardMenuModel> forward_menu_model_;
+
+  Browser* browser_;
+  Profile* profile_;
+
+  // Controls whether or not a home button should be shown on the toolbar.
+  BooleanPrefMember show_home_button_;
+};
+
+#endif
diff --git a/chrome/browser/gtk/browser_window_factory_gtk.cc b/chrome/browser/gtk/browser_window_factory_gtk.cc
new file mode 100644
index 0000000..5367341
--- /dev/null
+++ b/chrome/browser/gtk/browser_window_factory_gtk.cc
@@ -0,0 +1,12 @@
+// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "chrome/browser/browser_window.h"
+
+#include "chrome/browser/gtk/browser_window_gtk.h"
+
+BrowserWindow* BrowserWindow::CreateBrowserWindow(Browser* browser) {
+  return new BrowserWindowGtk(browser);
+}
+
diff --git a/chrome/browser/gtk/browser_window_gtk.cc b/chrome/browser/gtk/browser_window_gtk.cc
new file mode 100644
index 0000000..8ec0f44
--- /dev/null
+++ b/chrome/browser/gtk/browser_window_gtk.cc
@@ -0,0 +1,229 @@
+// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "chrome/browser/gtk/browser_window_gtk.h"
+
+#include "base/logging.h"
+#include "chrome/browser/browser.h"
+#include "chrome/browser/gtk/browser_toolbar_view_gtk.h"
+
+namespace {
+
+gboolean MainWindowDestroyed(GtkWindow* window, BrowserWindowGtk* browser_win) {
+  delete browser_win;
+  return FALSE;  // Don't stop this message.
+}
+
+gboolean MainWindowConfigured(GtkWindow* window, GdkEventConfigure* event,
+                              BrowserWindowGtk* browser_win) {
+  gfx::Rect bounds = gfx::Rect(event->x, event->y, event->width, event->height);
+  browser_win->OnBoundsChanged(bounds);
+  return FALSE;
+}
+
+gboolean MainWindowStateChanged(GtkWindow* window, GdkEventWindowState* event,
+                                BrowserWindowGtk* browser_win) {
+  browser_win->OnStateChanged(event->new_window_state);
+  return FALSE;
+}
+
+// Using gtk_window_get_position/size creates a race condition, so only use
+// this to get the initial bounds.  After window creation, we pick up the
+// normal bounds by connecting to the configure-event signal.
+gfx::Rect GetInitialWindowBounds(GtkWindow* window) {
+  gint x, y, width, height;
+  gtk_window_get_position(window, &x, &y);
+  gtk_window_get_size(window, &width, &height);
+  return gfx::Rect(x, y, width, height);
+}
+
+}  // namespace
+
+BrowserWindowGtk::BrowserWindowGtk(Browser* browser) : browser_(browser) {
+  Init();
+}
+
+BrowserWindowGtk::~BrowserWindowGtk() {
+  Close();
+}
+
+void BrowserWindowGtk::Init() {
+  window_ = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
+  gtk_window_set_title(window_, "Chromium");
+  gtk_window_set_default_size(window_, 640, 480);
+  g_signal_connect(G_OBJECT(window_), "destroy",
+                   G_CALLBACK(MainWindowDestroyed), this);
+  g_signal_connect(G_OBJECT(window_), "configure-event",
+                   G_CALLBACK(MainWindowConfigured), this);
+  g_signal_connect(G_OBJECT(window_), "window-state-event",
+                   G_CALLBACK(MainWindowStateChanged), this);
+  bounds_ = GetInitialWindowBounds(window_);
+
+  GtkWidget* vbox = gtk_vbox_new(FALSE, 0);
+
+  toolbar_.reset(new BrowserToolbarGtk(browser_.get()));
+  toolbar_->Init(browser_->profile());
+  toolbar_->AddToolbarToBox(vbox);
+
+  gtk_container_add(GTK_CONTAINER(window_), vbox);
+}
+
+void BrowserWindowGtk::Show() {
+  gtk_widget_show_all(GTK_WIDGET(window_));
+}
+
+void BrowserWindowGtk::SetBounds(const gfx::Rect& bounds) {
+  gint x = static_cast<gint>(bounds.x());
+  gint y = static_cast<gint>(bounds.y());
+  gint width = static_cast<gint>(bounds.width());
+  gint height = static_cast<gint>(bounds.height());
+
+  gtk_window_move(window_, x, y);
+  gtk_window_resize(window_, width, height);
+}
+
+void BrowserWindowGtk::Close() {
+  if (!window_)
+    return;
+
+  gtk_widget_destroy(GTK_WIDGET(window_));
+  window_ = NULL;
+}
+
+void BrowserWindowGtk::Activate() {
+  gtk_window_present(window_);
+}
+
+void BrowserWindowGtk::FlashFrame() {
+  // May not be respected by all window managers.
+  gtk_window_set_urgency_hint(window_, TRUE);
+}
+
+void* BrowserWindowGtk::GetNativeHandle() {
+  return window_;
+}
+
+BrowserWindowTesting* BrowserWindowGtk::GetBrowserWindowTesting() {
+  NOTIMPLEMENTED();
+  return NULL;
+}
+
+StatusBubble* BrowserWindowGtk::GetStatusBubble() {
+  NOTIMPLEMENTED();
+  return NULL;
+}
+
+void BrowserWindowGtk::SelectedTabToolbarSizeChanged(bool is_animating) {
+  NOTIMPLEMENTED();
+}
+
+void BrowserWindowGtk::UpdateTitleBar() {
+  NOTIMPLEMENTED();
+}
+
+void BrowserWindowGtk::UpdateLoadingAnimations(bool should_animate) {
+  NOTIMPLEMENTED();
+}
+
+void BrowserWindowGtk::SetStarredState(bool is_starred) {
+  NOTIMPLEMENTED();
+}
+
+gfx::Rect BrowserWindowGtk::GetNormalBounds() const {
+  return bounds_;
+}
+
+bool BrowserWindowGtk::IsMaximized() {
+  return (state_ & GDK_WINDOW_STATE_MAXIMIZED);
+}
+
+LocationBar* BrowserWindowGtk::GetLocationBar() const {
+  NOTIMPLEMENTED();
+  return NULL;
+}
+
+void BrowserWindowGtk::UpdateStopGoState(bool is_loading) {
+  NOTIMPLEMENTED();
+}
+
+void BrowserWindowGtk::UpdateToolbar(TabContents* contents,
+                                     bool should_restore_state) {
+  NOTIMPLEMENTED();
+}
+
+void BrowserWindowGtk::FocusToolbar() {
+  NOTIMPLEMENTED();
+}
+
+bool BrowserWindowGtk::IsBookmarkBarVisible() const {
+  NOTIMPLEMENTED();
+  return false;
+}
+
+void BrowserWindowGtk::ToggleBookmarkBar() {
+  NOTIMPLEMENTED();
+}
+
+void BrowserWindowGtk::ShowAboutChromeDialog() {
+  NOTIMPLEMENTED();
+}
+
+void BrowserWindowGtk::ShowBookmarkManager() {
+  NOTIMPLEMENTED();
+}
+
+bool BrowserWindowGtk::IsBookmarkBubbleVisible() const {
+  NOTIMPLEMENTED();
+  return false;
+}
+
+void BrowserWindowGtk::ShowBookmarkBubble(const GURL& url,
+                                          bool already_bookmarked) {
+  NOTIMPLEMENTED();
+}
+
+void BrowserWindowGtk::ShowReportBugDialog() {
+  NOTIMPLEMENTED();
+}
+
+void BrowserWindowGtk::ShowClearBrowsingDataDialog() {
+  NOTIMPLEMENTED();
+}
+
+void BrowserWindowGtk::ShowImportDialog() {
+  NOTIMPLEMENTED();
+}
+
+void BrowserWindowGtk::ShowSearchEnginesDialog() {
+  NOTIMPLEMENTED();
+}
+
+void BrowserWindowGtk::ShowPasswordManager() {
+  NOTIMPLEMENTED();
+}
+
+void BrowserWindowGtk::ShowSelectProfileDialog() {
+  NOTIMPLEMENTED();
+}
+
+void BrowserWindowGtk::ShowNewProfileDialog() {
+  NOTIMPLEMENTED();
+}
+
+void BrowserWindowGtk::ShowHTMLDialog(HtmlDialogContentsDelegate* delegate,
+                                      void* parent_window) {
+  NOTIMPLEMENTED();
+}
+
+void BrowserWindowGtk::DestroyBrowser() {
+  browser_.reset();
+}
+
+void BrowserWindowGtk::OnBoundsChanged(const gfx::Rect& bounds) {
+  bounds_ = bounds;
+}
+
+void BrowserWindowGtk::OnStateChanged(GdkWindowState state) {
+  state_ = state;
+}
diff --git a/chrome/browser/gtk/browser_window_gtk.h b/chrome/browser/gtk/browser_window_gtk.h
new file mode 100644
index 0000000..cbf8a1e3
--- /dev/null
+++ b/chrome/browser/gtk/browser_window_gtk.h
@@ -0,0 +1,79 @@
+ // Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CHROME_BROWSER_WINDOW_GTK_H_
+#define CHROME_BROWSER_WINDOW_GTK_H_
+
+#include <gtk/gtk.h>
+
+#include "base/gfx/rect.h"
+#include "base/scoped_ptr.h"
+#include "chrome/browser/browser_window.h"
+
+class BrowserToolbarGtk;
+
+// An implementation of BrowserWindow for GTK.
+// Cross-platform code will interact with this object when
+// it needs to manipulate the window.
+
+class BrowserWindowGtk : public BrowserWindow {
+ public:
+  explicit BrowserWindowGtk(Browser* browser);
+  virtual ~BrowserWindowGtk();
+
+  // Overridden from BrowserWindow
+  virtual void Init();
+  virtual void Show();
+  virtual void SetBounds(const gfx::Rect& bounds);
+  virtual void Close();
+  virtual void Activate();
+  virtual void FlashFrame();
+  virtual void* GetNativeHandle();
+  virtual BrowserWindowTesting* GetBrowserWindowTesting();
+  virtual StatusBubble* GetStatusBubble();
+  virtual void SelectedTabToolbarSizeChanged(bool is_animating);
+  virtual void UpdateTitleBar();
+  virtual void UpdateLoadingAnimations(bool should_animate);
+  virtual void SetStarredState(bool is_starred);
+  virtual gfx::Rect GetNormalBounds() const;
+  virtual bool IsMaximized();
+  virtual LocationBar* GetLocationBar() const;
+  virtual void UpdateStopGoState(bool is_loading);
+  virtual void UpdateToolbar(TabContents* contents,
+                             bool should_restore_state);
+  virtual void FocusToolbar();
+  virtual bool IsBookmarkBarVisible() const;
+  virtual void ToggleBookmarkBar();
+  virtual void ShowAboutChromeDialog();
+  virtual void ShowBookmarkManager();
+  virtual bool IsBookmarkBubbleVisible() const;
+  virtual void ShowBookmarkBubble(const GURL& url, bool already_bookmarked);
+  virtual void ShowReportBugDialog();
+  virtual void ShowClearBrowsingDataDialog();
+  virtual void ShowImportDialog();
+  virtual void ShowSearchEnginesDialog();
+  virtual void ShowPasswordManager();
+  virtual void ShowSelectProfileDialog();
+  virtual void ShowNewProfileDialog();
+  virtual void ShowHTMLDialog(HtmlDialogContentsDelegate* delegate,
+                              void* parent_window);
+
+  void OnBoundsChanged(const gfx::Rect& bounds);
+  void OnStateChanged(GdkWindowState state);
+
+ protected:
+  virtual void DestroyBrowser();
+  GtkWindow* window_;
+
+  scoped_ptr<Browser> browser_;
+
+ private:
+  gfx::Rect bounds_;
+  GdkWindowState state_;
+
+  scoped_ptr<BrowserToolbarGtk> toolbar_;
+};
+
+#endif  // CHROME_BROWSER_WINDOW_GTK_H_
+