Multi-tab selection for Linux.

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"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/autocomplete/autocomplete.h"
 #include "chrome/browser/autocomplete/autocomplete_classifier.h"
 #include "chrome/browser/autocomplete/autocomplete_match.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/tabs/tab_strip_model_delegate.h"
 #include "chrome/browser/themes/theme_service.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/browser/ui/gtk/browser_window_gtk.h"
 #include "chrome/browser/ui/gtk/custom_button.h"
 #include "chrome/browser/ui/gtk/gtk_theme_service.h"
 #include "chrome/browser/ui/gtk/gtk_util.h"
+#include "chrome/browser/ui/gtk/tabs/context_menu_controller.h"
 #include "chrome/browser/ui/gtk/tabs/dragged_tab_controller_gtk.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/common/notification_service.h"
 #include "content/common/notification_type.h"
 #include "grit/app_resources.h"
 #include "grit/theme_resources.h"
 #include "grit/theme_resources_standard.h"
 #include "ui/base/animation/animation_delegate.h"
 #include "ui/base/animation/slide_animation.h"
@@ skipping 127 matching lines @@
   static double GetCurrentTabWidth(TabStripGtk* tabstrip,
                                    TabStripGtk::TabAnimation* animation,
                                    int index) {
     TabGtk* tab = tabstrip->GetTabAt(index);
     double tab_width;
     if (tab->mini()) {
       tab_width = TabGtk::GetMiniWidth();
     } else {
       double unselected, selected;
       tabstrip->GetCurrentTabWidths(&unselected, &selected);
-      tab_width = tab->IsSelected() ? selected : unselected;
+      tab_width = tab->IsActive() ? selected : unselected;
     }
 
     if (animation) {
       double specified_tab_width = animation->GetWidthForTab(index);
       if (specified_tab_width != -1)
         tab_width = specified_tab_width;
     }
 
     return tab_width;
   }
@@ skipping 113 matching lines @@
       double delta = target_width - start_width;
       if (delta > 0)
         return start_width + (delta * animation_.GetCurrentValue());
 
       return start_width;
     }
 
     if (tabstrip_->GetTabAt(index)->mini())
       return TabGtk::GetMiniWidth();
 
-    if (tabstrip_->GetTabAt(index)->IsSelected()) {
+    if (tabstrip_->GetTabAt(index)->IsActive()) {
       double delta = end_selected_width_ - start_selected_width_;
       return start_selected_width_ + (delta * animation_.GetCurrentValue());
     }
 
     double delta = end_unselected_width_ - start_unselected_width_;
     return start_unselected_width_ + (delta * animation_.GetCurrentValue());
   }
 
  private:
   int index_;
@@ skipping 60 matching lines @@
     if (tab->mini())
       return TabGtk::GetMiniWidth();
 
     if (tabstrip_->available_width_for_tabs_ != -1 &&
         index_ != tabstrip_->GetTabCount() - 1) {
       return TabStripGtk::TabAnimation::GetWidthForTab(index);
     }
 
     // All other tabs are sized according to the start/end widths specified at
     // the start of the animation.
-    if (tab->IsSelected()) {
+    if (tab->IsActive()) {
       double delta = end_selected_width_ - start_selected_width_;
       return start_selected_width_ + (delta * animation_.GetCurrentValue());
     }
 
     double delta = end_unselected_width_ - start_unselected_width_;
     return start_unselected_width_ + (delta * animation_.GetCurrentValue());
   }
 
   virtual void AnimationEnded(const ui::Animation* animation) {
     tabstrip_->RemoveTabAt(index_);
@@ skipping 87 matching lines @@
   virtual int GetDuration() const {
     return kResizeLayoutAnimationDurationMs;
   }
 
   virtual double GetWidthForTab(int index) const {
     TabGtk* tab = tabstrip_->GetTabAt(index);
 
     if (tab->mini())
       return TabGtk::GetMiniWidth();
 
-    if (tab->IsSelected()) {
+    if (tab->IsActive()) {
       return animation_.CurrentValueBetween(start_selected_width_,
                                             end_selected_width_);
     }
 
     return animation_.CurrentValueBetween(start_unselected_width_,
                                           end_unselected_width_);
   }
 
  private:
   // We need to start from the current widths of the Tabs as they were last
   // laid out, _not_ the last known good state, which is what'll be done if we
   // don't measure the Tab sizes here and just go with the default TabAnimation
   // behavior...
   void InitStartState() {
     for (int i = 0; i < tabstrip_->GetTabCount(); ++i) {
       TabGtk* current_tab = tabstrip_->GetTabAt(i);
       if (!current_tab->mini()) {
-        if (current_tab->IsSelected()) {
+        if (current_tab->IsActive()) {
           start_selected_width_ = current_tab->width();
         } else {
           start_unselected_width_ = current_tab->width();
         }
       }
     }
   }
 
   DISALLOW_COPY_AND_ASSIGN(ResizeLayoutAnimation);
 };
@@ skipping 33 matching lines @@
             static_cast<double>(TabGtk::GetMiniWidth()));
       } else {
         return animation_.CurrentValueBetween(
             static_cast<double>(TabGtk::GetMiniWidth()),
             end_selected_width_);
       }
     } else if (tab->mini()) {
       return TabGtk::GetMiniWidth();
     }
 
-    if (tab->IsSelected()) {
+    if (tab->IsActive()) {
       return animation_.CurrentValueBetween(start_selected_width_,
                                             end_selected_width_);
     }
 
     return animation_.CurrentValueBetween(start_unselected_width_,
                                           end_unselected_width_);
   }
 
  private:
   // Index of the tab whose mini-state changed.
@@ skipping 77 matching lines @@
 
   virtual double GetWidthForTab(int index) const {
     TabGtk* tab = tabstrip_->GetTabAt(index);
 
     if (index == to_index_)
       return animation_.CurrentValueBetween(0, target_bounds_.width());
 
     if (tab->mini())
       return TabGtk::GetMiniWidth();
 
-    if (tab->IsSelected()) {
+    if (tab->IsActive()) {
       return animation_.CurrentValueBetween(start_selected_width_,
                                             end_selected_width_);
     }
 
     return animation_.CurrentValueBetween(start_unselected_width_,
                                           end_unselected_width_);
   }
 
  private:
   // The tab being moved.
@@ skipping 373 matching lines @@
   GenerateIdealBounds();
   StartMoveTabAnimation(from_index, to_index);
 }
 
 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->IsSelected())
+    if (tab->mini() && !tab->IsActive())
       tab->StartMiniTabTitleAnimation();
     // We'll receive another notification of the change asynchronously.
     return;
   }
   tab->UpdateData(contents->tab_contents(),
                   model_->IsAppTab(index),
                   change_type == LOADING_ONLY);
   tab->UpdateFromModel();
 }
 
@@ skipping 21 matching lines @@
 }
 
 void TabStripGtk::TabBlockedStateChanged(TabContentsWrapper* contents,
                                          int index) {
   GetTabAt(index)->SetBlocked(model_->IsTabBlocked(index));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TabStripGtk, TabGtk::TabDelegate implementation:
 
-bool TabStripGtk::IsTabSelected(const TabGtk* tab) const {
+bool TabStripGtk::IsTabActive(const TabGtk* tab) const {
   if (tab->closing())
     return false;
 
   return GetIndexOfTab(tab) == model_->active_index();
 }
 
+bool TabStripGtk::IsTabSelected(const TabGtk* tab) const {
+  if (tab->closing())
+    return false;
+
+  return model_->IsTabSelected(GetIndexOfTab(tab));
+}
+
 bool TabStripGtk::IsTabDetached(const TabGtk* tab) const {
   if (drag_controller_.get())
     return drag_controller_->IsTabDetached(tab);
   return false;
 }
 
 void TabStripGtk::GetCurrentTabWidths(double* unselected_width,
                                       double* selected_width) const {
   *unselected_width = current_unselected_width_;
   *selected_width = current_selected_width_;
 }
 
 bool TabStripGtk::IsTabPinned(const TabGtk* tab) const {
   if (tab->closing())
     return false;
 
   return model_->IsTabPinned(GetIndexOfTab(tab));
 }
 
-void TabStripGtk::SelectTab(TabGtk* tab) {
+void TabStripGtk::ActivateTab(TabGtk* tab) {
   int index = GetIndexOfTab(tab);
   if (model_->ContainsIndex(index))

[Evan Stade, 2011/05/11 20:58:27]

when could this check be false? why isn't it used in IsTabPinned or
GetContextMenuControllerForTab?

[dpapad, 2011/05/11 23:30:20]

I din not change these checks and I do not know if it is needed. I had no
indication to remove it either (documentation of ContainsIndex does not give any
examples).

[Evan Stade, 2011/05/12 00:05:27]

you didn't change this check but you did duplicate it. It would be nice to know
why you are deciding to duplicate it when you might have decided to leave it
off. As far as whether it's better to proof your code against unexpected
failure, I think it's not: this will just cover up other programming errors.

"It is far better to receive detailed crash reports than vague anecdotes about
unreproducible hangs, dead clicks, or other misbehaving non-crash
conditions."[1]

[1] http://www.chromium.org/developers/coding-style

[dpapad, 2011/05/12 00:34:25]

I am removing it from ToggleSelection(), since according to my understanding
this is not possible (cant control+click on a tab that is not in the strip).
Also a DCHECK is not needed since it is performed already within
TabStripModel::ToggleSelectionAt. Do you know whether unit tests cover these
cases?

     model_->ActivateTabAt(index, true);
 }
 
+void TabStripGtk::ToggleTabSelection(TabGtk* tab) {
+  int index = GetIndexOfTab(tab);
+  if (model_->ContainsIndex(index))
+    model_->ToggleSelectionAt(index);
+}
+
+void TabStripGtk::ExtendTabSelection(TabGtk* tab) {
+  int index = GetIndexOfTab(tab);
+  if (model_->ContainsIndex(index))
+    model_->ExtendSelectionTo(index);
+}
+
 void TabStripGtk::CloseTab(TabGtk* tab) {
   int tab_index = GetIndexOfTab(tab);
   if (model_->ContainsIndex(tab_index)) {
     TabGtk* last_tab = GetTabAt(GetTabCount() - 1);
     // Limit the width available to the TabStrip for laying out Tabs, so that
     // Tabs are not resized until a later time (when the mouse pointer leaves
     // the TabStrip).
     available_width_for_tabs_ = GetAvailableWidthForTabs(last_tab);
     needs_resize_layout_ = true;
     // We hook into the message loop in order to receive mouse move events when
@@ skipping 66 matching lines @@
 }
 
 bool TabStripGtk::HasAvailableDragActions() const {
   return model_->delegate()->GetDragActions() != 0;
 }
 
 ui::ThemeProvider* TabStripGtk::GetThemeProvider() {
   return theme_service_;
 }
 
+ContextMenuController* TabStripGtk::GetContextMenuControllerForTab(
+    TabGtk* tab) {
+  return new ContextMenuController(tab, model(), GetIndexOfTab(tab));
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // TabStripGtk, MessageLoop::Observer implementation:
 
 void TabStripGtk::WillProcessEvent(GdkEvent* event) {
   // Nothing to do.
 }
 
 void TabStripGtk::DidProcessEvent(GdkEvent* event) {
   switch (event->type) {
     case GDK_MOTION_NOTIFY:
@@ skipping 112 matching lines @@
 
   // NOTE: This currently assumes a tab's height doesn't differ based on
   // selected state or the number of tabs in the strip!
   int tab_height = TabGtk::GetStandardSize().height();
   double tab_x = tab_start_x();
   for (int i = 0; i < tab_count; ++i) {
     TabGtk* tab = GetTabAt(i);
     double tab_width = unselected;
     if (tab->mini())
       tab_width = TabGtk::GetMiniWidth();
-    else if (tab->IsSelected())
+    else if (tab->IsActive())
       tab_width = selected;
     double end_of_tab = tab_x + tab_width;
     int rounded_tab_x = Round(tab_x);
     gfx::Rect state(rounded_tab_x, 0, Round(end_of_tab) - rounded_tab_x,
                     tab_height);
     tab_data_.at(i).ideal_bounds = state;
     tab_x = end_of_tab + GetTabHOffset(i + 1);
   }
 }
 
@@ skipping 123 matching lines @@
   available_width_for_tabs_ = -1;
   int mini_tab_count = GetMiniTabCount();
   if (mini_tab_count == GetTabCount()) {
     // Only mini tabs, we know the tab widths won't have changed (all mini-tabs
     // have the same width), so there is nothing to do.
     return false;
   }
   TabGtk* first_tab = GetTabAt(mini_tab_count);
   double unselected, selected;
   GetDesiredTabWidths(GetTabCount(), mini_tab_count, &unselected, &selected);
-  int w = Round(first_tab->IsSelected() ? selected : unselected);
+  int w = Round(first_tab->IsActive() ? selected : unselected);
 
   // We only want to run the animation if we're not already at the desired
   // size.
   if (abs(first_tab->width() - w) > 1) {
     StartResizeLayoutAnimation();
     return true;
   }
 
   return false;
 }
@@ skipping 408 matching lines @@
       newtab_button_->widget(), event);
 
   // Paint the tabs in reverse order, so they stack to the left.
   TabGtk* selected_tab = NULL;
   int tab_count = GetTabCount();
   for (int i = tab_count - 1; i >= 0; --i) {
     TabGtk* tab = GetTabAt(i);
     // We must ask the _Tab's_ model, not ourselves, because in some situations
     // the model will be different to this object, e.g. when a Tab is being
     // removed after its TabContents has been destroyed.
-    if (!tab->IsSelected()) {
+    if (!tab->IsActive()) {
       gtk_container_propagate_expose(GTK_CONTAINER(tabstrip_.get()),
                                      tab->widget(), event);
     } else {
       selected_tab = tab;
     }
   }
 
   // Paint the selected tab last, so it overlaps all the others.
   if (selected_tab) {
     gtk_container_propagate_expose(GTK_CONTAINER(tabstrip_.get()),
@@ skipping 142 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_UNSET_FLAGS(button->widget(), GTK_CAN_FOCUS);
   gtk_fixed_put(GTK_FIXED(tabstrip_.get()), button->widget(), 0, 0);
 
   return button;
 }