Change the visual appearance of panel on GTK per new UI design.

chrome/browser/ui/gtk/browser_titlebar.cc

 // Copyright (c) 2012 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 38 matching lines @@
 #include "grit/theme_resources.h"
 #include "grit/theme_resources_standard.h"
 #include "grit/ui_resources.h"
 #include "grit/ui_resources_standard.h"
 #include "ui/base/gtk/gtk_hig_constants.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/x/active_window_watcher_x.h"
 #include "ui/gfx/gtk_util.h"
 #include "ui/gfx/image/image.h"
-#include "ui/gfx/skbitmap_operations.h"
 
 using content::WebContents;
 
 namespace {
 
 // The space above the titlebars.
 const int kTitlebarHeight = 14;
 
 // The thickness in pixels of the tab border.
 const int kTabOuterThickness = 1;
@@ skipping 400 matching lines @@
     return titlebar_left_buttons_hbox_;
   else if (!left_side && titlebar_right_buttons_hbox_)
     return titlebar_right_buttons_hbox_;
 
   // We put the min/max/restore/close buttons in a vbox so they are top aligned
   // (up to padding) and don't vertically stretch.
   GtkWidget* vbox = left_side ? titlebar_left_buttons_vbox_ :
                     titlebar_right_buttons_vbox_;
 
   GtkWidget* top_padding = gtk_fixed_new();
-  gtk_widget_set_size_request(top_padding, -1, GetButtonOuterPadding());
+  gtk_widget_set_size_request(top_padding, -1, kButtonOuterPadding);
   gtk_box_pack_start(GTK_BOX(vbox), top_padding, FALSE, FALSE, 0);
 
-  GtkWidget* buttons_hbox = gtk_hbox_new(FALSE, GetButtonSpacing());
+  GtkWidget* buttons_hbox = gtk_hbox_new(FALSE, kButtonSpacing);
   gtk_box_pack_start(GTK_BOX(vbox), buttons_hbox, FALSE, FALSE, 0);
 
   if (left_side) {
     titlebar_left_buttons_hbox_ = buttons_hbox;
     top_padding_left_ = top_padding;
   } else {
     titlebar_right_buttons_hbox_ = buttons_hbox;
     top_padding_right_ = top_padding;
   }
 
   return buttons_hbox;
 }
 
-int BrowserTitlebar::GetButtonOuterPadding() const {
-  return kButtonOuterPadding;
-}
-
-int BrowserTitlebar::GetButtonSpacing() const {
-  return kButtonSpacing;
-}
-
 CustomDrawButton* BrowserTitlebar::CreateTitlebarButton(
     const std::string& button_name, bool left_side) {
   int normal_image_id;
   int pressed_image_id;
   int hover_image_id;
   int tooltip_id;
   GetButtonResources(button_name, &normal_image_id, &pressed_image_id,
                      &hover_image_id, &tooltip_id);
 
   CustomDrawButton* button = new CustomDrawButton(normal_image_id,
@@ skipping 185 matching lines @@
       gtk_widget_hide(titlebar_alignment_);
     }
   }
 
   // Resize the buttons so that the clickable area extends all the way to the
   // edge of the browser window.
   GtkRequisition close_button_req = close_button_req_;
   GtkRequisition minimize_button_req = minimize_button_req_;
   GtkRequisition restore_button_req = restore_button_req_;
   if (using_custom_frame_ && browser_window_->IsMaximized()) {
-    close_button_req.width += GetButtonOuterPadding();
-    close_button_req.height += GetButtonOuterPadding();
-    minimize_button_req.height += GetButtonOuterPadding();
-    restore_button_req.height += GetButtonOuterPadding();
+    close_button_req.width += kButtonOuterPadding;
+    close_button_req.height += kButtonOuterPadding;
+    minimize_button_req.height += kButtonOuterPadding;
+    restore_button_req.height += kButtonOuterPadding;
     if (top_padding_left_)
       gtk_widget_hide(top_padding_left_);
     if (top_padding_right_)
       gtk_widget_hide(top_padding_right_);
   } else {
     if (top_padding_left_)
       gtk_widget_show(top_padding_left_);
     if (top_padding_right_)
       gtk_widget_show(top_padding_right_);
   }
@@ skipping 106 matching lines @@
   }
   avatar_button_->SetIcon(avatar, is_gaia_picture);
 
   BubbleGtk::ArrowLocationGtk arrow_location =
       display_avatar_on_left_ ^ base::i18n::IsRTL() ?
           BubbleGtk::ARROW_LOCATION_TOP_LEFT :
           BubbleGtk::ARROW_LOCATION_TOP_RIGHT;
   avatar_button_->set_menu_arrow_location(arrow_location);
 }
 
-void BrowserTitlebar::ShowFaviconMenu(GdkEventButton* event) {
-  if (!favicon_menu_model_.get()) {
-    favicon_menu_model_.reset(
-        new PopupPageMenuModel(this, browser_window_->browser()));
-
-    favicon_menu_.reset(new MenuGtk(NULL, favicon_menu_model_.get()));
-  }
-
-  favicon_menu_->PopupForWidget(app_mode_favicon_, event->button, event->time);
-}
-
 void BrowserTitlebar::MaximizeButtonClicked() {
   GdkEvent* event = gtk_get_current_event();
   if (event->button.button == 1) {
     gtk_window_maximize(window_);
   } else {
     GtkWidget* widget = GTK_WIDGET(window_);
     GdkScreen* screen = gtk_widget_get_screen(widget);
     gint monitor = gdk_screen_get_monitor_at_window(
         screen, gtk_widget_get_window(widget));
     GdkRectangle screen_rect;
@@ skipping 47 matching lines @@
       event->direction == GDK_SCROLL_UP) {
     if (index != 0)
       browser->SelectPreviousTab();
   } else if (index + 1 < browser->tab_count()) {
     browser->SelectNextTab();
   }
   return TRUE;
 }
 
 void BrowserTitlebar::OnButtonClicked(GtkWidget* button) {
-  HandleButtonClick(button);
-}
-
-void BrowserTitlebar::HandleButtonClick(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_);
   }
 }
 
 gboolean BrowserTitlebar::OnFaviconMenuButtonPressed(GtkWidget* widget,
                                                      GdkEventButton* event) {
   if (event->button != 1)
     return FALSE;
 
-  ShowFaviconMenu(event);
+  if (!favicon_menu_model_.get()) {
+    favicon_menu_model_.reset(
+        new PopupPageMenuModel(this, browser_window_->browser()));
+
+    favicon_menu_.reset(new MenuGtk(NULL, favicon_menu_model_.get()));
+  }
+
+  favicon_menu_->PopupForWidget(app_mode_favicon_, event->button, event->time);
+
   return TRUE;
 }
 
 void BrowserTitlebar::ShowContextMenu(GdkEventButton* event) {
   if (!context_menu_.get()) {
     context_menu_model_.reset(new ContextMenuModel(this));
     context_menu_.reset(new MenuGtk(NULL, context_menu_model_.get()));
   }
 
   context_menu_->PopupAsContext(gfx::Point(event->x_root, event->y_root),
@@ skipping 97 matching lines @@
   if (!browser_window_->browser()->is_type_tabbed())
     return false;
 
   return AvatarMenuModel::ShouldShowAvatarMenu();
 }
 
 bool BrowserTitlebar::IsOffTheRecord() {
   return browser_window_->browser()->profile()->IsOffTheRecord();
 }
 
-///////////////////////////////////////////////////////////////////////////////
-// 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|.
-static void MakeThrobberFrames(int resource_id,
-                               std::vector<GdkPixbuf*>* frames) {
-  ui::ResourceBundle &rb = ui::ResourceBundle::GetSharedInstance();
-  SkBitmap* frame_strip = rb.GetBitmapNamed(resource_id);
-
-  // Each frame of the animation is a square, so we use the height as the
-  // frame size.
-  int frame_size = frame_strip->height();
-  size_t num_frames = frame_strip->width() / frame_size;
-
-  // Make a separate GdkPixbuf for each frame of the animation.
-  for (size_t i = 0; i < num_frames; ++i) {
-    SkBitmap frame = SkBitmapOperations::CreateTiledBitmap(*frame_strip,
-        i * frame_size, 0, frame_size, frame_size);
-    frames->push_back(gfx::GdkPixbufFromSkBitmap(frame));
-  }
+GtkWidget* BrowserTitlebar::widget() const {
+  return container_;
 }
 
-GdkPixbuf* BrowserTitlebar::Throbber::GetNextFrame(bool is_waiting) {
-  Throbber::InitFrames();
-  if (is_waiting) {
-    return (*g_throbber_waiting_frames)[current_waiting_frame_++ %
-        g_throbber_waiting_frames->size()];
-  } else {
-    return (*g_throbber_frames)[current_frame_++ % g_throbber_frames->size()];
-  }
+void BrowserTitlebar::set_window(GtkWindow* window) {
+  window_ = window;
 }
 
-void BrowserTitlebar::Throbber::Reset() {
-  current_frame_ = 0;
-  current_waiting_frame_ = 0;
-}
-
-// static
-void BrowserTitlebar::Throbber::InitFrames() {
-  if (g_throbber_frames)
-    return;
-
-  // We load the light version of the throbber since it'll be in the titlebar.
-  g_throbber_frames = new std::vector<GdkPixbuf*>;
-  MakeThrobberFrames(IDR_THROBBER_LIGHT, g_throbber_frames);
-
-  g_throbber_waiting_frames = new std::vector<GdkPixbuf*>;
-  MakeThrobberFrames(IDR_THROBBER_WAITING_LIGHT, g_throbber_waiting_frames);
+AvatarMenuButtonGtk* BrowserTitlebar::avatar_button() const {
+  return avatar_button_.get();
 }
 
 BrowserTitlebar::ContextMenuModel::ContextMenuModel(
     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);
 }