Gtk: Make click target of tabs match their appearance.

chrome/browser/ui/gtk/tabs/tab_strip_gtk.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/tabs/tab_strip_gtk.h"
 
 #include <algorithm>
 
 #include "base/i18n/rtl.h"
 #include "base/string_util.h"
@@ skipping 732 matching lines @@
   gtk_drag_dest_set(tabstrip_.get(), GTK_DEST_DEFAULT_ALL,
                     NULL, 0,
                     static_cast<GdkDragAction>(
                         GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK));
   static const int targets[] = { ui::TEXT_URI_LIST,
                                  ui::NETSCAPE_URL,
                                  ui::TEXT_PLAIN,
                                  -1 };
   ui::SetDestTargetList(tabstrip_.get(), targets);
 
+  g_signal_connect(tabstrip_.get(), "map",
+                   G_CALLBACK(OnMapThunk), this);
   g_signal_connect(tabstrip_.get(), "expose-event",
                    G_CALLBACK(OnExposeThunk), this);
   g_signal_connect(tabstrip_.get(), "size-allocate",
                    G_CALLBACK(OnSizeAllocateThunk), this);
   g_signal_connect(tabstrip_.get(), "drag-motion",
                    G_CALLBACK(OnDragMotionThunk), this);
   g_signal_connect(tabstrip_.get(), "drag-drop",
                    G_CALLBACK(OnDragDropThunk), this);
   g_signal_connect(tabstrip_.get(), "drag-leave",
                    G_CALLBACK(OnDragLeaveThunk), this);
@@ skipping 236 matching lines @@
   // Don't animate the first tab; it looks weird.
   if (GetTabCount() > 1) {
     StartInsertTabAnimation(index);
     // We added the tab at 0x0, we need to force an animation step otherwise
     // if GTK paints before the animation event the tab is painted at 0x0
     // which is most likely not where it should be positioned.
     active_animation_->AnimationProgressed(NULL);
   } else {
     Layout();
   }
+
+  ReStack();
 }
 
 void TabStripGtk::TabDetachedAt(TabContentsWrapper* contents, int index) {
   GenerateIdealBounds();
   StartRemoveTabAnimation(index, contents->tab_contents());
   // Have to do this _after_ calling StartRemoveTabAnimation, so that any
   // previous remove is completed fully and index is valid in sync with the
   // model index.
   GetTabAt(index)->set_closing(true);
 }
 
+void TabStripGtk::ActiveTabChanged(TabContentsWrapper* old_contents,
+                                   TabContentsWrapper* new_contents,
+                                   int index,
+                                   bool user_gesture) {
+  ReStack();
+}
+
 void TabStripGtk::TabSelectionChanged(const TabStripSelectionModel& old_model) {
   // We have "tiny tabs" if the tabs are so tiny that the unselected ones are
   // a different size to the selected ones.
   bool tiny_tabs = current_unselected_width_ != current_selected_width_;
   if (!IsAnimating() && (!needs_resize_layout_ || tiny_tabs))
     Layout();
 
   if (model_->active_index() >= 0)
     GetTabAt(model_->active_index())->SchedulePaint();
 
@@ skipping 38 matching lines @@
                            int to_index) {
   gfx::Rect start_bounds = GetIdealBounds(from_index);
   TabGtk* tab = GetTabAt(from_index);
   tab_data_.erase(tab_data_.begin() + from_index);
   TabData data = {tab, gfx::Rect()};
   tab->set_mini(model_->IsMiniTab(to_index));
   tab->SetBlocked(model_->IsTabBlocked(to_index));
   tab_data_.insert(tab_data_.begin() + to_index, data);
   GenerateIdealBounds();
   StartMoveTabAnimation(from_index, to_index);
+  ReStack();
 }
 
 void TabStripGtk::TabChangedAt(TabContentsWrapper* contents, int index,
                                TabChangeType change_type) {
   // Index is in terms of the model. Need to make sure we adjust that index in
   // case we have an animation going.
   TabGtk* tab = GetTabAtAdjustForAnimation(index);
   if (change_type == TITLE_NOT_LOADING) {
     if (tab->mini() && !tab->IsActive())
       tab->StartMiniTabTitleAnimation();
@@ skipping 485 matching lines @@
 
   GdkScreen* screen = gdk_screen_get_default();
   GdkDisplay* display = gdk_screen_get_display(screen);
   gint x, y;
   gdk_display_get_pointer(display, NULL, &x, &y, NULL);
   gfx::Point cursor_point(x, y);
 
   return bds.Contains(cursor_point);
 }
 
+void TabStripGtk::ReStack() {
+  if (!GTK_WIDGET_REALIZED(tabstrip_.get())) {
+    // If the window isn't realized yet, we can't stack them yet. It will be
+    // done by the OnMap signal handler.
+    return;
+  }
+  int tab_count = GetTabCount();
+  TabGtk* active_tab = NULL;
+  for (int i = tab_count - 1; i >= 0; --i) {
+    TabGtk* tab = GetTabAt(i);
+    if (tab->IsActive())
+      active_tab = tab;
+    else
+      tab->Raise();
+  }
+  if (active_tab)
+    active_tab->Raise();
+}
+
+
 void TabStripGtk::AddMessageLoopObserver() {
   if (!added_as_message_loop_observer_) {
     MessageLoopForUI::current()->AddObserver(this);
     added_as_message_loop_observer_ = true;
   }
 }
 
 void TabStripGtk::RemoveMessageLoopObserver() {
   if (added_as_message_loop_observer_) {
     MessageLoopForUI::current()->RemoveObserver(this);
@@ skipping 337 matching lines @@
   active_animation_.reset(NULL);
 
   // Reset the animation state of each tab.
   for (int i = 0, count = GetTabCount(); i < count; ++i)
     GetTabAt(i)->set_animating_mini_change(false);
 
   if (layout)
     Layout();
 }
 
+void TabStripGtk::OnMap(GtkWidget* widget) {
+  ReStack();
+}
+
 gboolean TabStripGtk::OnExpose(GtkWidget* widget, GdkEventExpose* event) {
   if (gdk_region_empty(event->region))
     return TRUE;
 
   // If we're only repainting favicons, optimize the paint path and only draw
   // the favicons.
   GdkRectangle* rects;
   gint num_rects;
   gdk_region_get_rectangles(event->region, &rects, &num_rects);
   qsort(rects, num_rects, sizeof(GdkRectangle), CompareGdkRectangles);
@@ skipping 186 matching lines @@
 
   // Let the middle mouse button initiate clicks as well.
   gtk_util::SetButtonTriggersNavigation(button->widget());
   g_signal_connect(button->widget(), "clicked",
                    G_CALLBACK(OnNewTabClickedThunk), this);
   gtk_widget_set_can_focus(button->widget(), FALSE);
   gtk_fixed_put(GTK_FIXED(tabstrip_.get()), button->widget(), 0, 0);
 
   return button;
 }