Multi-tab selection for Linux.

chrome/browser/ui/gtk/tabs/tab_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_gtk.h"
 
 #include <gdk/gdkkeysyms.h>
 
 #include "base/memory/singleton.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/ui/gtk/accelerators_gtk.h"
 #include "chrome/browser/ui/gtk/menu_gtk.h"
+#include "chrome/browser/ui/gtk/tabs/tab_strip_menu_controller.h"
 #include "chrome/browser/ui/tabs/tab_menu_model.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "ui/base/dragdrop/gtk_dnd_util.h"
 #include "ui/base/models/accelerator_gtk.h"
 #include "ui/gfx/path.h"
 
 namespace {
 
 // Returns the width of the title for the current font, in pixels.
 int GetTitleWidth(gfx::Font* font, string16 title) {
   DCHECK(font);
   if (title.empty())
     return 0;
 
   return font->GetStringWidth(title);
 }
 
 }  // namespace
 
-class TabGtk::ContextMenuController : public ui::SimpleMenuModel::Delegate,
-                                      public MenuGtk::Delegate {
- public:
-  explicit ContextMenuController(TabGtk* tab)
-      : tab_(tab),
-        model_(this, tab->delegate()->IsTabPinned(tab)) {
-    menu_.reset(new MenuGtk(this, &model_));
-  }
-
-  virtual ~ContextMenuController() {}
-
-  void RunMenu(const gfx::Point& point, guint32 event_time) {
-    menu_->PopupAsContext(point, event_time);
-  }
-
-  void Cancel() {
-    tab_ = NULL;
-    menu_->Cancel();
-  }
-
- private:
-  // Overridden from ui::SimpleMenuModel::Delegate:
-  virtual bool IsCommandIdChecked(int command_id) const {
-    return false;
-  }
-  virtual bool IsCommandIdEnabled(int command_id) const {
-    return tab_ && tab_->delegate()->IsCommandEnabledForTab(
-        static_cast<TabStripModel::ContextMenuCommand>(command_id),
-        tab_);
-  }
-  virtual bool GetAcceleratorForCommandId(
-      int command_id,
-      ui::Accelerator* accelerator) {
-    int browser_command;
-    if (!TabStripModel::ContextMenuCommandToBrowserCommand(command_id,
-                                                           &browser_command))
-      return false;
-    const ui::AcceleratorGtk* accelerator_gtk =
-        AcceleratorsGtk::GetInstance()->GetPrimaryAcceleratorForCommand(
-            browser_command);
-    if (accelerator_gtk)
-      *accelerator = *accelerator_gtk;
-    return !!accelerator_gtk;
-  }
-
-  virtual void ExecuteCommand(int command_id) {
-    if (!tab_)
-      return;
-    tab_->delegate()->ExecuteCommandForTab(
-        static_cast<TabStripModel::ContextMenuCommand>(command_id), tab_);
-  }
-
-  GtkWidget* GetImageForCommandId(int command_id) const {
-    int browser_cmd_id;
-    return TabStripModel::ContextMenuCommandToBrowserCommand(command_id,
-                                                             &browser_cmd_id) ?
-        MenuGtk::Delegate::GetDefaultImageForCommandId(browser_cmd_id) :
-        NULL;
-  }
-
-  // The context menu.
-  scoped_ptr<MenuGtk> menu_;
-
-  // The Tab the context menu was brought up for. Set to NULL when the menu
-  // is canceled.
-  TabGtk* tab_;
-
-  // The model.
-  TabMenuModel model_;
-
-  DISALLOW_COPY_AND_ASSIGN(ContextMenuController);
-};
-
 class TabGtk::TabGtkObserverHelper {
  public:
   explicit TabGtkObserverHelper(TabGtk* tab)
       : tab_(tab) {
     MessageLoopForUI::current()->AddObserver(tab_);
   }
 
   ~TabGtkObserverHelper() {
     MessageLoopForUI::current()->RemoveObserver(tab_);
   }
@@ skipping 52 matching lines @@
   }
 }
 
 gboolean TabGtk::OnButtonPressEvent(GtkWidget* widget, GdkEventButton* event) {
   // Every button press ensures either a button-release-event or a drag-fail
   // signal for |widget|.
   if (event->button == 1 && event->type == GDK_BUTTON_PRESS) {
     // Store whether or not we were selected just now... we only want to be
     // able to drag foreground tabs, so we don't start dragging the tab if
     // it was in the background.
-    bool just_selected = !IsSelected();
-    if (just_selected) {
-      delegate_->SelectTab(this);
+    if (!IsActive()) {
+      if (event->state & GDK_CONTROL_MASK)
+        delegate_->ToggleTabSelection(this);
+      else if (event->state & GDK_SHIFT_MASK)
+        delegate_->ExtendTabSelection(this);
+      else
+        delegate_->ActivateTab(this);
     }
-
     // Hook into the message loop to handle dragging.
     observer_.reset(new TabGtkObserverHelper(this));
 
     // Store the button press event, used to initiate a drag.
     last_mouse_down_ = gdk_event_copy(reinterpret_cast<GdkEvent*>(event));
   } else if (event->button == 3) {
     // Only show the context menu if the left mouse button isn't down (i.e.,
     // the user might want to drag instead).
     if (!last_mouse_down_) {
-      menu_controller_.reset(new ContextMenuController(this));
+      menu_controller_.reset(delegate()->GetTabStripMenuControllerForTab(this));
       menu_controller_->RunMenu(gfx::Point(event->x_root, event->y_root),
                                 event->time);
     }
   }
 
   return TRUE;
 }
 
 gboolean TabGtk::OnButtonReleaseEvent(GtkWidget* widget,
                                       GdkEventButton* event) {
   if (event->button == 1) {
+    if (IsActive() && !(event->state & (GDK_SHIFT_MASK | GDK_CONTROL_MASK))) {
+      delegate_->ActivateTab(this);
+    }
     observer_.reset();
 
     if (last_mouse_down_) {
       gdk_event_free(last_mouse_down_);
       last_mouse_down_ = NULL;
     }
   }
 
   // Middle mouse up means close the tab, but only if the mouse is over it
   // (like a button).
@@ skipping 71 matching lines @@
       static_cast<gint>(new_x), static_cast<gint>(new_y))) {
     StartDragging(gfx::Point(
         static_cast<int>(last_mouse_down_->button.x),
         static_cast<int>(last_mouse_down_->button.y)));
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // TabGtk, TabRendererGtk overrides:
 
+bool TabGtk::IsActive() const {
+  return delegate_->IsTabActive(this);
+}
+
 bool TabGtk::IsSelected() const {
   return delegate_->IsTabSelected(this);
 }
 
 bool TabGtk::IsVisible() const {
   return GTK_WIDGET_FLAGS(event_box_) & GTK_VISIBLE;
 }
 
 void TabGtk::SetVisible(bool visible) const {
   if (visible) {
@@ skipping 81 matching lines @@
     gdk_event_free(last_mouse_down_);
     last_mouse_down_ = NULL;
   }
 
   // Notify the drag helper that we're done with any potential drag operations.
   // Clean up the drag helper, which is re-created on the next mouse press.
   delegate_->EndDrag(canceled);
 
   observer_.reset();
 }