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/dragged_tab_controller_gtk.h"
+#include "chrome/browser/ui/gtk/tabs/tab_strip_menu_controller.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"
 #include "ui/base/dragdrop/gtk_dnd_util.h"
@@ skipping 126 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 332 matching lines @@
 
 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) {
-  DCHECK(index >= 0 && index < static_cast<int>(GetTabCount()));
-
+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();
 
-  GetTabAt(index)->SchedulePaint();
+  std::vector<int> indices_affected;
+  std::insert_iterator<std::vector<int> > it1(indices_affected,
+                                              indices_affected.begin());
+  std::set_symmetric_difference(

[dpapad, 2011/06/24 20:17:16]

Done. 
I see one issue here. Since there is no longer
"GetTabAt(index)->SchedulePaint();"
and |index| will not end up necessarily in the |indices_affected| (for example:
before: selected,not-active, now: selected and active), should it explicitly be
repainted?

+      old_model.selected_indices().begin(),
+      old_model.selected_indices().end(),
+      model_->selection_model().selected_indices().begin(),
+      model_->selection_model().selected_indices().end(),
+      it1);
+  for (std::vector<int>::iterator it = indices_affected.begin();
+       it != indices_affected.end(); ++it)
+    GetTabAtAdjustForAnimation(*it)->SchedulePaint();
 
-  int old_index = model_->GetIndexOfTabContents(old_contents);
-  if (old_index >= 0) {
-    GetTabAt(old_index)->SchedulePaint();
-    GetTabAt(old_index)->StopMiniTabTitleAnimation();
+  TabStripSelectionModel::SelectedIndices no_longer_selected;
+  std::insert_iterator<std::vector<int> > it2(no_longer_selected,
+                                              no_longer_selected.begin());
+  std::set_difference(old_model.selected_indices().begin(),
+                      old_model.selected_indices().end(),
+                      model_->selection_model().selected_indices().begin(),
+                      model_->selection_model().selected_indices().end(),
+                      it2);
+  for (std::vector<int>::iterator it = no_longer_selected.begin();
+       it != no_longer_selected.end(); ++it) {
+    GetTabAtAdjustForAnimation(*it)->StopMiniTabTitleAnimation();
   }
 }
 
 void TabStripGtk::TabMoved(TabContentsWrapper* contents,
                            int from_index,
                            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);
 }
 
 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))
     model_->ActivateTabAt(index, true);
 }
 
+void TabStripGtk::ToggleTabSelection(TabGtk* tab) {
+  int index = GetIndexOfTab(tab);
+  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_;
 }
 
+TabStripMenuController* TabStripGtk::GetTabStripMenuControllerForTab(
+    TabGtk* tab) {
+  return new TabStripMenuController(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;
 }