1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#ifndef CHROME_BROWSER_UI_GTK_TABS_TAB_GTK_H_
6#define CHROME_BROWSER_UI_GTK_TABS_TAB_GTK_H_
7
8#include "base/basictypes.h"
9#include "base/compiler_specific.h"
10#include "base/memory/weak_ptr.h"
11#include "base/message_loop/message_loop.h"
12#include "chrome/browser/ui/gtk/tabs/tab_renderer_gtk.h"
13#include "chrome/browser/ui/tabs/tab_strip_model.h"
14#include "ui/base/gtk/gtk_signal.h"
15
16class TabStripMenuController;
17class ThemeService;
18
19class TabGtk : public TabRendererGtk, public base::MessageLoopForUI::Observer {
20 public:
21  // An interface implemented by an object that can help this Tab complete
22  // various actions. The index parameter is the index of this Tab in the
23  // TabRenderer::Model.
24  class TabDelegate {
25   public:
26    // Returns true if the specified Tab is active.
27    virtual bool IsTabActive(const TabGtk* tab) const = 0;
28
29    // Returns true if the specified Tab is selected.
30    virtual bool IsTabSelected(const TabGtk* tab) const = 0;
31
32    // Returns true if the specified Tab is pinned.
33    virtual bool IsTabPinned(const TabGtk* tab) const = 0;
34
35    // Returns true if the specified Tab is detached.
36    virtual bool IsTabDetached(const TabGtk* tab) const = 0;
37
38    // Activates the specified Tab.
39    virtual void ActivateTab(TabGtk* tab) = 0;
40
41    // Toggles selection of the specified Tab.
42    virtual void ToggleTabSelection(TabGtk* tab) = 0;
43
44    // Extends selection from the anchor to the specified Tab.
45    virtual void ExtendTabSelection(TabGtk* tab) = 0;
46
47    // Closes the specified Tab.
48    virtual void CloseTab(TabGtk* tab) = 0;
49
50    // Returns true if the specified command is enabled for the specified Tab.
51    virtual bool IsCommandEnabledForTab(
52        TabStripModel::ContextMenuCommand command_id,
53        const TabGtk* tab) const = 0;
54
55    // Executes the specified command for the specified Tab.
56    virtual void ExecuteCommandForTab(
57        TabStripModel::ContextMenuCommand command_id, TabGtk* tab) = 0;
58
59    // Starts/Stops highlighting the tabs that will be affected by the
60    // specified command for the specified Tab.
61    virtual void StartHighlightTabsForCommand(
62        TabStripModel::ContextMenuCommand command_id, TabGtk* tab) = 0;
63    virtual void StopHighlightTabsForCommand(
64        TabStripModel::ContextMenuCommand command_id, TabGtk* tab) = 0;
65    virtual void StopAllHighlighting() = 0;
66
67    // Potentially starts a drag for the specified Tab.
68    virtual void MaybeStartDrag(TabGtk* tab, const gfx::Point& point) = 0;
69
70    // Continues dragging a Tab.
71    virtual void ContinueDrag(GdkDragContext* context) = 0;
72
73    // Ends dragging a Tab. |canceled| is true if the drag was aborted in a way
74    // other than the user releasing the mouse. Returns whether the tab has been
75    // destroyed.
76    virtual bool EndDrag(bool canceled) = 0;
77
78    // Returns true if the associated TabStrip's delegate supports tab moving or
79    // detaching. Used by the Frame to determine if dragging on the Tab
80    // itself should move the window in cases where there's only one
81    // non drag-able Tab.
82    virtual bool HasAvailableDragActions() const = 0;
83
84    // Returns the theme provider for icons and colors.
85    virtual GtkThemeService* GetThemeProvider() = 0;
86
87    // Returns a context menu controller for |tab|. Caller takes ownership of
88    // the pointed object.
89    virtual TabStripMenuController* GetTabStripMenuControllerForTab(
90        TabGtk* tab) = 0;
91
92   protected:
93    virtual ~TabDelegate() {}
94  };
95
96  explicit TabGtk(TabDelegate* delegate);
97  virtual ~TabGtk();
98
99  // Access the delegate.
100  TabDelegate* delegate() const { return delegate_; }
101
102  GtkWidget* widget() const { return event_box_; }
103
104  // Used to set/check whether this Tab is being animated closed.
105  void set_closing(bool closing) { closing_ = closing; }
106  bool closing() const { return closing_; }
107
108  // Used to set/check whether this Tab is being dragged.
109  void set_dragging(bool dragging) { dragging_ = dragging; }
110  bool dragging() const { return dragging_; }
111
112  // Raise to top of Z-order.
113  void Raise() const;
114
115  // TabRendererGtk overrides:
116  virtual bool IsActive() const OVERRIDE;
117  virtual bool IsSelected() const OVERRIDE;
118  virtual bool IsVisible() const OVERRIDE;
119  virtual void SetVisible(bool visible) const OVERRIDE;
120  virtual void CloseButtonClicked() OVERRIDE;
121  virtual void UpdateData(content::WebContents* contents,
122                          bool app,
123                          bool loading_only) OVERRIDE;
124  virtual void SetBounds(const gfx::Rect& bounds) OVERRIDE;
125
126 private:
127  class TabGtkObserverHelper;
128
129  // MessageLoop::Observer implementation:
130  virtual void WillProcessEvent(GdkEvent* event) OVERRIDE;
131  virtual void DidProcessEvent(GdkEvent* event) OVERRIDE;
132
133  // button-press-event handler that handles mouse clicks.
134  CHROMEGTK_CALLBACK_1(TabGtk, gboolean, OnButtonPressEvent, GdkEventButton*);
135
136  // button-release-event handler that handles mouse click releases.
137  CHROMEGTK_CALLBACK_1(TabGtk, gboolean, OnButtonReleaseEvent, GdkEventButton*);
138
139  // drag-begin is emitted when the drag is started. We connect so that we can
140  // set the drag icon to a transparent pixbuf.
141  CHROMEGTK_CALLBACK_1(TabGtk, void, OnDragBegin, GdkDragContext*);
142
143  // drag-failed is emitted when the drag is finished.  In our case the signal
144  // does not imply failure as we don't use the drag-n-drop API to transfer drop
145  // data.
146  CHROMEGTK_CALLBACK_2(TabGtk, gboolean, OnDragFailed, GdkDragContext*,
147                       GtkDragResult);
148
149  // When a drag is ending, a fake button release event is passed to the drag
150  // widget to fake letting go of the mouse button.  We need a callback for
151  // this event because it is the only way to catch drag end events when the
152  // user presses space or return.
153  CHROMEGTK_CALLBACK_1(TabGtk, gboolean, OnDragButtonReleased, GdkEventButton*);
154
155  // Invoked when the context menu closes.
156  void ContextMenuClosed();
157
158  // Sets whether the tooltip should be shown or not, depending on the size of
159  // the tab.
160  void UpdateTooltipState();
161
162  // Creates the drag widget used to track a drag operation.
163  void CreateDragWidget();
164
165  // Destroys the drag widget.
166  void DestroyDragWidget();
167
168  // Starts the dragging operation.  |drag_offset| is the offset inside the tab
169  // bounds where the grab occurred.
170  void StartDragging(gfx::Point drag_offset);
171
172  // Ends the dragging operations.  |canceled| is true if the operation was
173  // canceled.
174  void EndDrag(bool canceled);
175
176  // An instance of a delegate object that can perform various actions based on
177  // user gestures.
178  TabDelegate* delegate_;
179
180  // True if the tab is being animated closed.
181  bool closing_;
182
183  // True if the tab is being dragged.
184  bool dragging_;
185
186  // The context menu controller.
187  scoped_ptr<TabStripMenuController> menu_controller_;
188
189  // The windowless widget used to collect input events for the tab.  We can't
190  // use an OwnedWidgetGtk because of the way the dragged tab controller
191  // destroys the source tab.  The source tab is destroyed when the drag ends
192  // before we let gtk handle the end of the drag.  This results in the widget
193  // having an extra reference, which will cause OwnedWidgetGtk.Destroy to
194  // DCHECK.
195  GtkWidget* event_box_;
196
197  // A copy of the last button press event, used to initiate a drag.
198  GdkEvent* last_mouse_down_;
199
200  // A GtkInivisible used to track the drag event.  GtkInvisibles are of the
201  // type GInitiallyUnowned, but the widget initialization code sinks the
202  // reference, so we can't used an OwnedWidgetGtk here.
203  GtkWidget* drag_widget_;
204
205  // The cached width of the title in pixels, updated whenever the title
206  // changes.
207  int title_width_;
208
209  // Keep track of whether or not we have an observer.
210  scoped_ptr<TabGtkObserverHelper> observer_;
211
212  // Used to destroy the drag widget after a return to the message loop.
213  base::WeakPtrFactory<TabGtk> destroy_factory_;
214
215  // Due to a bug in GTK+, we need to force the end of a drag when we get a
216  // mouse release event on the the dragged widget, otherwise, we don't know
217  // when the drag has ended when the user presses space or enter.  We queue
218  // a task to end the drag and only run it if GTK+ didn't send us the
219  // drag-failed event.
220  base::WeakPtrFactory<TabGtk> drag_end_factory_;
221
222  DISALLOW_COPY_AND_ASSIGN(TabGtk);
223};
224
225#endif  // CHROME_BROWSER_UI_GTK_TABS_TAB_GTK_H_
226