Titlebar modifications for panels.

chrome/browser/ui/gtk/browser_titlebar.cc

 // Copyright (c) 2011 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/ui/gtk/browser_titlebar.h"
 
 #include <gdk/gdkkeysyms.h>
 #include <gtk/gtk.h>
 
 #include <string>
@@ skipping 201 matching lines @@
       titlebar_left_buttons_hbox_(NULL),
       titlebar_right_buttons_hbox_(NULL),
       titlebar_left_spy_frame_(NULL),
       titlebar_right_spy_frame_(NULL),
       top_padding_left_(NULL),
       top_padding_right_(NULL),
       app_mode_favicon_(NULL),
       app_mode_title_(NULL),
       using_custom_frame_(false),
       window_has_focus_(false),
+      window_has_mouse_(false),
       theme_service_(NULL) {
   Init();
 }
 
 void BrowserTitlebar::Init() {
   // The widget hierarchy is shown below.
   //
   // +- EventBox (container_) ------------------------------------------------+
   // +- HBox (container_hbox_) -----------------------------------------------+
   // |+ VBox ---++- Algn. -++- Alignment --------------++- Algn. -++ VBox ---+|
@@ skipping 45 matching lines @@
   container_ = gtk_event_box_new();
   gtk_widget_set_name(container_, "chrome-browser-titlebar");
   gtk_event_box_set_visible_window(GTK_EVENT_BOX(container_), FALSE);
   gtk_container_add(GTK_CONTAINER(container_), container_hbox_);
 
   g_signal_connect(container_, "scroll-event", G_CALLBACK(OnScrollThunk), this);
 
   g_signal_connect(window_, "window-state-event",
                    G_CALLBACK(OnWindowStateChangedThunk), this);
 
+  if (IsTypePanel()) {
+    g_signal_connect(window_, "enter-notify-event",
+                     G_CALLBACK(OnEnterNotifyThunk), this);
+    g_signal_connect(window_, "leave-notify-event",
+                     G_CALLBACK(OnLeaveNotifyThunk), this);
+  }
+
   // Allocate the two button boxes on the left and right parts of the bar,
   // spyguy frames in case of incognito mode, and profile button boxes.
   titlebar_left_buttons_vbox_ = gtk_vbox_new(FALSE, 0);
   gtk_box_pack_start(GTK_BOX(container_hbox_), titlebar_left_buttons_vbox_,
                      FALSE, FALSE, 0);
   if (browser_window_->browser()->profile()->IsOffTheRecord() &&
       browser_window_->browser()->is_type_tabbed()) {
     titlebar_left_spy_frame_ = gtk_alignment_new(0.0, 0.0, 1.0, 1.0);
     gtk_widget_set_no_show_all(titlebar_left_spy_frame_, TRUE);
     gtk_alignment_set_padding(GTK_ALIGNMENT(titlebar_left_spy_frame_), 0,
@@ skipping 72 matching lines @@
                        FALSE, 0);
     // We use the app logo as a placeholder image so the title doesn't jump
     // around.
     ResourceBundle& rb = ResourceBundle::GetSharedInstance();
     app_mode_favicon_ = gtk_image_new_from_pixbuf(
         rb.GetRTLEnabledPixbufNamed(IDR_PRODUCT_LOGO_16));
     g_object_set_data(G_OBJECT(app_mode_favicon_), "left-align-popup",
                       reinterpret_cast<void*>(true));
     gtk_container_add(GTK_CONTAINER(favicon_event_box), app_mode_favicon_);
 
+    if (IsTypePanel()) {
+      panel_wrench_button_.reset(
+          BuildTitlebarButton(IDR_BALLOON_WRENCH, IDR_BALLOON_WRENCH_P,
+                              IDR_BALLOON_WRENCH_H, app_mode_hbox, FALSE,
+                              IDS_NEW_TAB_APP_SETTINGS));
+      gtk_widget_set_no_show_all(panel_wrench_button_->widget(), TRUE);
+    }
+
     app_mode_title_ = gtk_label_new(NULL);
     gtk_label_set_ellipsize(GTK_LABEL(app_mode_title_), PANGO_ELLIPSIZE_END);
     gtk_misc_set_alignment(GTK_MISC(app_mode_title_), 0.0, 0.5);
     gtk_box_pack_start(GTK_BOX(app_mode_hbox), app_mode_title_, TRUE, TRUE,
                        0);
 
     // Register with the theme provider to set the |app_mode_title_| label
     // color.
     theme_service_ = GtkThemeService::GetFrom(
         browser_window_->browser()->profile());
@@ skipping 32 matching lines @@
   StringTokenizer tokenizer(button_string, ":,");
   tokenizer.set_options(StringTokenizer::RETURN_DELIMS);
   int left_count = 0;
   int right_count = 0;
   while (tokenizer.GetNext()) {
     if (tokenizer.token_is_delim()) {
       if (*tokenizer.token_begin() == ':')
         left_side = false;
     } else {
       base::StringPiece token = tokenizer.token_piece();
-      if (token == "minimize") {
+      if (token == "minimize" && !IsTypePanel()) {
         (left_side ? left_count : right_count)++;
         GtkWidget* parent_box = GetButtonHBox(left_side);
         minimize_button_.reset(
             BuildTitlebarButton(IDR_MINIMIZE, IDR_MINIMIZE_P,
-                                IDR_MINIMIZE_H, parent_box,
+                                IDR_MINIMIZE_H, parent_box, true,
                                 IDS_XPFRAME_MINIMIZE_TOOLTIP));
 
         gtk_widget_size_request(minimize_button_->widget(),
                                 &minimize_button_req_);
-      } else if (token == "maximize") {
+      } else if (token == "maximize" && !IsTypePanel()) {
         (left_side ? left_count : right_count)++;
         GtkWidget* parent_box = GetButtonHBox(left_side);
         restore_button_.reset(
             BuildTitlebarButton(IDR_RESTORE, IDR_RESTORE_P,
-                                IDR_RESTORE_H, parent_box,
+                                IDR_RESTORE_H, parent_box, true,
                                 IDS_XPFRAME_RESTORE_TOOLTIP));
         maximize_button_.reset(
             BuildTitlebarButton(IDR_MAXIMIZE, IDR_MAXIMIZE_P,
-                                IDR_MAXIMIZE_H, parent_box,
+                                IDR_MAXIMIZE_H, parent_box, true,
                                 IDS_XPFRAME_MAXIMIZE_TOOLTIP));
 
         gtk_util::SetButtonClickableByMouseButtons(maximize_button_->widget(),
                                                    true, true, true);
         gtk_widget_size_request(restore_button_->widget(),
                                 &restore_button_req_);
       } else if (token == "close") {
         (left_side ? left_count : right_count)++;
         GtkWidget* parent_box = GetButtonHBox(left_side);
         close_button_.reset(
             BuildTitlebarButton(IDR_CLOSE, IDR_CLOSE_P,
-                                IDR_CLOSE_H, parent_box,
+                                IDR_CLOSE_H, parent_box, true,
                                 IDS_XPFRAME_CLOSE_TOOLTIP));
         close_button_->set_flipped(left_side);
 
         gtk_widget_size_request(close_button_->widget(), &close_button_req_);
       }
       // Ignore any other values like "pin" since we don't have images for
       // those.
     }
   }
 
@@ skipping 52 matching lines @@
     top_padding_left_ = top_padding;
   } else {
     titlebar_right_buttons_hbox_ = buttons_hbox;
     top_padding_right_ = top_padding;
   }
 
   return buttons_hbox;
 }
 
 CustomDrawButton* BrowserTitlebar::BuildTitlebarButton(int image,
-    int image_pressed, int image_hot, GtkWidget* box, int tooltip) {
+    int image_pressed, int image_hot, GtkWidget* box, bool start,
+    int tooltip) {
   CustomDrawButton* button = new CustomDrawButton(image, image_pressed,
                                                   image_hot, 0);
   gtk_widget_add_events(GTK_WIDGET(button->widget()), GDK_POINTER_MOTION_MASK);
   g_signal_connect(button->widget(), "clicked",
                    G_CALLBACK(OnButtonClickedThunk), this);
   g_signal_connect(button->widget(), "motion-notify-event",
                    G_CALLBACK(OnMouseMoveEvent), browser_window_);
   std::string localized_tooltip = l10n_util::GetStringUTF8(tooltip);
   gtk_widget_set_tooltip_text(button->widget(),
                               localized_tooltip.c_str());
-  gtk_box_pack_start(GTK_BOX(box), button->widget(), FALSE, FALSE, 0);
+  if (start)
+    gtk_box_pack_start(GTK_BOX(box), button->widget(), FALSE, FALSE, 0);
+  else
+    gtk_box_pack_end(GTK_BOX(box), button->widget(), FALSE, FALSE, 0);
   return button;
 }
 
 void BrowserTitlebar::UpdateCustomFrame(bool use_custom_frame) {
   using_custom_frame_ = use_custom_frame;
   if (!use_custom_frame ||
       (browser_window_->IsMaximized() && unity::IsRunning())) {
     if (titlebar_left_buttons_vbox_)
       gtk_widget_hide(titlebar_left_buttons_vbox_);
     if (titlebar_right_buttons_vbox_)
@@ skipping 11 matching lines @@
 void BrowserTitlebar::UpdateTitleAndIcon() {
   if (!app_mode_title_)
     return;
 
   // Get the page title and elide it to the available space.
   string16 title = browser_window_->browser()->GetWindowTitleForCurrentTab();
   gtk_label_set_text(GTK_LABEL(app_mode_title_), UTF16ToUTF8(title).c_str());
 
   // Note: we want to exclude the application popup window.
   if (browser_window_->browser()->is_app() &&
-      !browser_window_->browser()->is_type_popup()) {
+      browser_window_->browser()->is_type_tabbed()) {
     // Update the system app icon.  We don't need to update the icon in the top
     // left of the custom frame, that will get updated when the throbber is
     // updated.
     SkBitmap icon = browser_window_->browser()->GetCurrentPageIcon();
     if (icon.empty()) {
       gtk_util::SetWindowIcon(window_);
     } else {
       GdkPixbuf* icon_pixbuf = gfx::GdkPixbufFromSkBitmap(&icon);
       gtk_window_set_icon(window_, icon_pixbuf);
       g_object_unref(icon_pixbuf);
@@ skipping 206 matching lines @@
   if (event->direction == GDK_SCROLL_LEFT ||
       event->direction == GDK_SCROLL_UP) {
     if (index != 0)
       tabstrip_model->SelectPreviousTab();
   } else if (index + 1 < tabstrip_model->count()) {
     tabstrip_model->SelectNextTab();
   }
   return TRUE;
 }
 
+gboolean BrowserTitlebar::OnEnterNotify(GtkWidget* widget,
+                                        GdkEventCrossing* event) {
+  // Ignore if entered from a child widget.
+  if (event->detail == GDK_NOTIFY_INFERIOR)
+    return FALSE;
+
+  if (window_ && panel_wrench_button_.get())
+    gtk_widget_show(panel_wrench_button_->widget());
+
+  window_has_mouse_ = TRUE;
+  return FALSE;
+}
+
+gboolean BrowserTitlebar::OnLeaveNotify(GtkWidget* widget,
+                                        GdkEventCrossing* event) {
+  // Ignore if left towards a child widget.
+  if (event->detail == GDK_NOTIFY_INFERIOR)
+    return FALSE;
+
+  if (window_ && panel_wrench_button_.get() && !window_has_focus_)
+    gtk_widget_hide(panel_wrench_button_->widget());
+
+  window_has_mouse_ = FALSE;
+  return FALSE;
+}
+
 // static
 void BrowserTitlebar::OnButtonClicked(GtkWidget* button) {
   if (close_button_.get() && close_button_->widget() == button) {
     browser_window_->Close();
   } else if (restore_button_.get() && restore_button_->widget() == button) {
     browser_window_->UnMaximize();
   } else if (maximize_button_.get() && maximize_button_->widget() == button) {
     MaximizeButtonClicked();
   } else if (minimize_button_.get() && minimize_button_->widget() == button) {
     gtk_window_iconify(window_);
@@ skipping 90 matching lines @@
   }
 }
 
 void BrowserTitlebar::ActiveWindowChanged(GdkWindow* active_window) {
   // Can be called during shutdown; BrowserWindowGtk will set our |window_|
   // to NULL during that time.
   if (!window_)
     return;
 
   window_has_focus_ = GTK_WIDGET(window_)->window == active_window;
+  if (IsTypePanel()) {
+    if (window_has_focus_ || window_has_mouse_)
+      gtk_widget_show(panel_wrench_button_->widget());
+    else
+      gtk_widget_hide(panel_wrench_button_->widget());
+  }
   UpdateTextColor();
 }
 
+bool BrowserTitlebar::IsTypePanel() {
+  return CommandLine::ForCurrentProcess()->HasSwitch(switches::kEnablePanels) &&

[jennb, 2011/06/23 23:09:43]

browser.cc converts type to POPUP if --enable-panels is not defined so you
shouldn't need this check here.

[prasadt, 2011/06/24 00:01:11]

Chatted offline.
Looks like we convert TYPE_PANEL to TYPE_POPUP in the absence of the flag,
except for ChromeOS.  And this file is not compiled on ChromeOS.  Its not that
obvious from reading the code, so did it this way to be safe.  I can remove the
check on a later CL.

+      browser_window_->browser()->is_type_panel();
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // BrowserTitlebar::Throbber implementation
 // TODO(tc): Handle anti-clockwise spinning when waiting for a connection.
 
 // We don't bother to clean up these or the pixbufs they contain when we exit.
 static std::vector<GdkPixbuf*>* g_throbber_frames = NULL;
 static std::vector<GdkPixbuf*>* g_throbber_waiting_frames = NULL;
 
 // Load |resource_id| from the ResourceBundle and split it into a series of
 // square GdkPixbufs that get stored in |frames|.
@@ skipping 47 matching lines @@
     ui::SimpleMenuModel::Delegate* delegate)
     : SimpleMenuModel(delegate) {
   AddItemWithStringId(IDC_NEW_TAB, IDS_TAB_CXMENU_NEWTAB);
   AddItemWithStringId(IDC_RESTORE_TAB, IDS_RESTORE_TAB);
   AddSeparator();
   AddItemWithStringId(IDC_TASK_MANAGER, IDS_TASK_MANAGER);
   AddSeparator();
   AddCheckItemWithStringId(kShowWindowDecorationsCommand,
                            IDS_SHOW_WINDOW_DECORATIONS_MENU);
 }