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 <vector>

[sky, 2011/06/23 18:14:03]

This is already included by the header.

[dpapad, 2011/06/23 19:56:02]

Done.

 
 #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 353 matching lines @@
 
   GetTabAt(index)->SchedulePaint();
 
   int old_index = model_->GetIndexOfTabContents(old_contents);
   if (old_index >= 0) {
     GetTabAt(old_index)->SchedulePaint();
     GetTabAt(old_index)->StopMiniTabTitleAnimation();
   }
 }
 
+void TabStripGtk::TabSelectionChanged(const TabStripSelectionModel& old_model) {
+  std::vector<int> indices_affected;
+  std::insert_iterator<std::vector<int> > it(indices_affected,
+                                             indices_affected.begin());
+  std::set_symmetric_difference(
+      old_model.selected_indices().begin(),
+      old_model.selected_indices().end(),
+      model_->selection_model().selected_indices().begin(),
+      model_->selection_model().selected_indices().end(),
+      it);
+  for (std::vector<int>::iterator it = indices_affected.begin();

[sky, 2011/06/23 18:14:03]

If there is a deletion in progress then the indices from the model don't line up
with the indices of the TabStrip. This is true of all the methods in this class
though, so you might just want to add a TODO some where that it needs to be
straightened out.

[dpapad, 2011/06/23 19:56:02]

Why is that happening? In TabStripModel::DetachTabContentsAt() we store the
|old_model| after calling DecrementFrom. Also observers should get a
TabClosingAt notification before getting notified of any TabSelectionChanged,
right?

+      it != indices_affected.end(); ++it)

[James Hawkins, 2011/06/23 18:08:26]

nit: Indentation looks off by one here.

[dpapad, 2011/06/23 19:56:02]

Done.

+    GetTabAt(*it)->SchedulePaint();
+}
+
 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;
 }