1// Copyright (c) 2011 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#include "chrome/browser/ui/gtk/status_bubble_gtk.h"
6
7#include <gtk/gtk.h>
8
9#include <algorithm>
10
11#include "base/i18n/rtl.h"
12#include "base/message_loop.h"
13#include "base/utf_string_conversions.h"
14#include "chrome/browser/ui/gtk/gtk_theme_service.h"
15#include "chrome/browser/ui/gtk/gtk_util.h"
16#include "chrome/browser/ui/gtk/rounded_window.h"
17#include "chrome/browser/ui/gtk/slide_animator_gtk.h"
18#include "content/common/notification_service.h"
19#include "ui/base/animation/slide_animation.h"
20#include "ui/base/text/text_elider.h"
21
22namespace {
23
24// Inner padding between the border and the text label.
25const int kInternalTopBottomPadding = 1;
26const int kInternalLeftRightPadding = 2;
27
28// The radius of the edges of our bubble.
29const int kCornerSize = 3;
30
31// Milliseconds before we hide the status bubble widget when you mouseout.
32const int kHideDelay = 250;
33
34// How close the mouse can get to the infobubble before it starts sliding
35// off-screen.
36const int kMousePadding = 20;
37
38}  // namespace
39
40StatusBubbleGtk::StatusBubbleGtk(Profile* profile)
41    : theme_service_(GtkThemeService::GetFrom(profile)),
42      padding_(NULL),
43      flip_horizontally_(false),
44      y_offset_(0),
45      download_shelf_is_visible_(false),
46      last_mouse_location_(0, 0),
47      last_mouse_left_content_(false),
48      ignore_next_left_content_(false) {
49  InitWidgets();
50
51  theme_service_->InitThemesFor(this);
52  registrar_.Add(this, NotificationType::BROWSER_THEME_CHANGED,
53                 NotificationService::AllSources());
54}
55
56StatusBubbleGtk::~StatusBubbleGtk() {
57  label_.Destroy();
58  container_.Destroy();
59}
60
61void StatusBubbleGtk::SetStatus(const string16& status_text_wide) {
62  std::string status_text = UTF16ToUTF8(status_text_wide);
63  if (status_text_ == status_text)
64    return;
65
66  status_text_ = status_text;
67  if (!status_text_.empty())
68    SetStatusTextTo(status_text_);
69  else if (!url_text_.empty())
70    SetStatusTextTo(url_text_);
71  else
72    SetStatusTextTo(std::string());
73}
74
75void StatusBubbleGtk::SetURL(const GURL& url, const string16& languages) {
76  url_ = url;
77  languages_ = languages;
78
79  // If we want to clear a displayed URL but there is a status still to
80  // display, display that status instead.
81  if (url.is_empty() && !status_text_.empty()) {
82    url_text_ = std::string();
83    SetStatusTextTo(status_text_);
84    return;
85  }
86
87  SetStatusTextToURL();
88}
89
90void StatusBubbleGtk::SetStatusTextToURL() {
91  GtkWidget* parent = gtk_widget_get_parent(container_.get());
92
93  // It appears that parent can be NULL (probably only during shutdown).
94  if (!parent || !GTK_WIDGET_REALIZED(parent))
95    return;
96
97  int desired_width = parent->allocation.width;
98  if (!expanded()) {
99    expand_timer_.Stop();
100    expand_timer_.Start(base::TimeDelta::FromMilliseconds(kExpandHoverDelay),
101                        this, &StatusBubbleGtk::ExpandURL);
102    // When not expanded, we limit the size to one third the browser's
103    // width.
104    desired_width /= 3;
105  }
106
107  // TODO(tc): We don't actually use gfx::Font as the font in the status
108  // bubble.  We should extend ui::ElideUrl to take some sort of pango font.
109  url_text_ = UTF16ToUTF8(ui::ElideUrl(url_, gfx::Font(), desired_width,
110                          UTF16ToUTF8(languages_)));
111  SetStatusTextTo(url_text_);
112}
113
114void StatusBubbleGtk::Show() {
115  // If we were going to hide, stop.
116  hide_timer_.Stop();
117
118  gtk_widget_show(container_.get());
119  if (container_->window)
120    gdk_window_raise(container_->window);
121}
122
123void StatusBubbleGtk::Hide() {
124  // If we were going to expand the bubble, stop.
125  expand_timer_.Stop();
126  expand_animation_.reset();
127
128  gtk_widget_hide(container_.get());
129}
130
131void StatusBubbleGtk::SetStatusTextTo(const std::string& status_utf8) {
132  if (status_utf8.empty()) {
133    hide_timer_.Stop();
134    hide_timer_.Start(base::TimeDelta::FromMilliseconds(kHideDelay),
135                      this, &StatusBubbleGtk::Hide);
136  } else {
137    gtk_label_set_text(GTK_LABEL(label_.get()), status_utf8.c_str());
138    GtkRequisition req;
139    gtk_widget_size_request(label_.get(), &req);
140    desired_width_ = req.width;
141
142    UpdateLabelSizeRequest();
143
144    if (!last_mouse_left_content_) {
145      // Show the padding and label to update our requisition and then
146      // re-process the last mouse event -- if the label was empty before or the
147      // text changed, our size will have changed and we may need to move
148      // ourselves away from the pointer now.
149      gtk_widget_show_all(padding_);
150      MouseMoved(last_mouse_location_, false);
151    }
152    Show();
153  }
154}
155
156void StatusBubbleGtk::MouseMoved(
157    const gfx::Point& location, bool left_content) {
158  if (left_content && ignore_next_left_content_) {
159    ignore_next_left_content_ = false;
160    return;
161  }
162
163  last_mouse_location_ = location;
164  last_mouse_left_content_ = left_content;
165
166  if (!GTK_WIDGET_REALIZED(container_.get()))
167    return;
168
169  GtkWidget* parent = gtk_widget_get_parent(container_.get());
170  if (!parent || !GTK_WIDGET_REALIZED(parent))
171    return;
172
173  int old_y_offset = y_offset_;
174  bool old_flip_horizontally = flip_horizontally_;
175
176  if (left_content) {
177    SetFlipHorizontally(false);
178    y_offset_ = 0;
179  } else {
180    GtkWidget* toplevel = gtk_widget_get_toplevel(container_.get());
181    if (!toplevel || !GTK_WIDGET_REALIZED(toplevel))
182      return;
183
184    bool ltr = !base::i18n::IsRTL();
185
186    GtkRequisition requisition;
187    gtk_widget_size_request(container_.get(), &requisition);
188
189    // Get our base position (that is, not including the current offset)
190    // relative to the origin of the root window.
191    gint toplevel_x = 0, toplevel_y = 0;
192    gdk_window_get_position(toplevel->window, &toplevel_x, &toplevel_y);
193    gfx::Rect parent_rect =
194        gtk_util::GetWidgetRectRelativeToToplevel(parent);
195    gfx::Rect bubble_rect(
196        toplevel_x + parent_rect.x() +
197            (ltr ? 0 : parent->allocation.width - requisition.width),
198        toplevel_y + parent_rect.y() +
199            parent->allocation.height - requisition.height,
200        requisition.width,
201        requisition.height);
202
203    int left_threshold =
204        bubble_rect.x() - bubble_rect.height() - kMousePadding;
205    int right_threshold =
206        bubble_rect.right() + bubble_rect.height() + kMousePadding;
207    int top_threshold = bubble_rect.y() - kMousePadding;
208
209    if (((ltr && location.x() < right_threshold) ||
210         (!ltr && location.x() > left_threshold)) &&
211        location.y() > top_threshold) {
212      if (download_shelf_is_visible_) {
213        SetFlipHorizontally(true);
214        y_offset_ = 0;
215      } else {
216        SetFlipHorizontally(false);
217        int distance = std::max(ltr ?
218                                    location.x() - right_threshold :
219                                    left_threshold - location.x(),
220                                top_threshold - location.y());
221        y_offset_ = std::min(-1 * distance, requisition.height);
222      }
223    } else {
224      SetFlipHorizontally(false);
225      y_offset_ = 0;
226    }
227  }
228
229  if (y_offset_ != old_y_offset || flip_horizontally_ != old_flip_horizontally)
230    gtk_widget_queue_resize_no_redraw(parent);
231}
232
233void StatusBubbleGtk::UpdateDownloadShelfVisibility(bool visible) {
234  download_shelf_is_visible_ = visible;
235}
236
237void StatusBubbleGtk::Observe(NotificationType type,
238                              const NotificationSource& source,
239                              const NotificationDetails& details) {
240  if (type == NotificationType::BROWSER_THEME_CHANGED) {
241    UserChangedTheme();
242  }
243}
244
245void StatusBubbleGtk::InitWidgets() {
246  bool ltr = !base::i18n::IsRTL();
247
248  label_.Own(gtk_label_new(NULL));
249
250  padding_ = gtk_alignment_new(0, 0, 1, 1);
251  gtk_alignment_set_padding(GTK_ALIGNMENT(padding_),
252      kInternalTopBottomPadding, kInternalTopBottomPadding,
253      kInternalLeftRightPadding + (ltr ? 0 : kCornerSize),
254      kInternalLeftRightPadding + (ltr ? kCornerSize : 0));
255  gtk_container_add(GTK_CONTAINER(padding_), label_.get());
256  gtk_widget_show_all(padding_);
257
258  container_.Own(gtk_event_box_new());
259  gtk_widget_set_no_show_all(container_.get(), TRUE);
260  gtk_util::ActAsRoundedWindow(
261      container_.get(), gtk_util::kGdkWhite, kCornerSize,
262      gtk_util::ROUNDED_TOP_RIGHT,
263      gtk_util::BORDER_TOP | gtk_util::BORDER_RIGHT);
264  gtk_widget_set_name(container_.get(), "status-bubble");
265  gtk_container_add(GTK_CONTAINER(container_.get()), padding_);
266
267  // We need to listen for mouse motion events, since a fast-moving pointer may
268  // enter our window without us getting any motion events on the browser near
269  // enough for us to run away.
270  gtk_widget_add_events(container_.get(), GDK_POINTER_MOTION_MASK |
271                                          GDK_ENTER_NOTIFY_MASK);
272  g_signal_connect(container_.get(), "motion-notify-event",
273                   G_CALLBACK(HandleMotionNotifyThunk), this);
274  g_signal_connect(container_.get(), "enter-notify-event",
275                   G_CALLBACK(HandleEnterNotifyThunk), this);
276
277  UserChangedTheme();
278}
279
280void StatusBubbleGtk::UserChangedTheme() {
281  if (theme_service_->UseGtkTheme()) {
282    gtk_widget_modify_fg(label_.get(), GTK_STATE_NORMAL, NULL);
283    gtk_widget_modify_bg(container_.get(), GTK_STATE_NORMAL, NULL);
284  } else {
285    // TODO(erg): This is the closest to "text that will look good on a
286    // toolbar" that I can find. Maybe in later iterations of the theme system,
287    // there will be a better color to pick.
288    GdkColor bookmark_text =
289        theme_service_->GetGdkColor(ThemeService::COLOR_BOOKMARK_TEXT);
290    gtk_widget_modify_fg(label_.get(), GTK_STATE_NORMAL, &bookmark_text);
291
292    GdkColor toolbar_color =
293        theme_service_->GetGdkColor(ThemeService::COLOR_TOOLBAR);
294    gtk_widget_modify_bg(container_.get(), GTK_STATE_NORMAL, &toolbar_color);
295  }
296
297  gtk_util::SetRoundedWindowBorderColor(container_.get(),
298                                        theme_service_->GetBorderColor());
299}
300
301void StatusBubbleGtk::SetFlipHorizontally(bool flip_horizontally) {
302  if (flip_horizontally == flip_horizontally_)
303    return;
304
305  flip_horizontally_ = flip_horizontally;
306
307  bool ltr = !base::i18n::IsRTL();
308  bool on_left = (ltr && !flip_horizontally) || (!ltr && flip_horizontally);
309
310  gtk_alignment_set_padding(GTK_ALIGNMENT(padding_),
311      kInternalTopBottomPadding, kInternalTopBottomPadding,
312      kInternalLeftRightPadding + (on_left ? 0 : kCornerSize),
313      kInternalLeftRightPadding + (on_left ? kCornerSize : 0));
314  // The rounded window code flips these arguments if we're RTL.
315  gtk_util::SetRoundedWindowEdgesAndBorders(
316      container_.get(),
317      kCornerSize,
318      flip_horizontally ?
319          gtk_util::ROUNDED_TOP_LEFT :
320          gtk_util::ROUNDED_TOP_RIGHT,
321      gtk_util::BORDER_TOP |
322          (flip_horizontally ? gtk_util::BORDER_LEFT : gtk_util::BORDER_RIGHT));
323  gtk_widget_queue_draw(container_.get());
324}
325
326void StatusBubbleGtk::ExpandURL() {
327  start_width_ = label_.get()->allocation.width;
328  expand_animation_.reset(new ui::SlideAnimation(this));
329  expand_animation_->SetTweenType(ui::Tween::LINEAR);
330  expand_animation_->Show();
331
332  SetStatusTextToURL();
333}
334
335void StatusBubbleGtk::UpdateLabelSizeRequest() {
336  if (!expanded() || !expand_animation_->is_animating()) {
337    gtk_widget_set_size_request(label_.get(), -1, -1);
338    return;
339  }
340
341  int new_width = start_width_ +
342      (desired_width_ - start_width_) * expand_animation_->GetCurrentValue();
343  gtk_widget_set_size_request(label_.get(), new_width, -1);
344}
345
346// See http://crbug.com/68897 for why we have to handle this event.
347gboolean StatusBubbleGtk::HandleEnterNotify(GtkWidget* sender,
348                                            GdkEventCrossing* event) {
349  ignore_next_left_content_ = true;
350  MouseMoved(gfx::Point(event->x_root, event->y_root), false);
351  return FALSE;
352}
353
354gboolean StatusBubbleGtk::HandleMotionNotify(GtkWidget* sender,
355                                             GdkEventMotion* event) {
356  MouseMoved(gfx::Point(event->x_root, event->y_root), false);
357  return FALSE;
358}
359
360void StatusBubbleGtk::AnimationEnded(const ui::Animation* animation) {
361  UpdateLabelSizeRequest();
362}
363
364void StatusBubbleGtk::AnimationProgressed(const ui::Animation* animation) {
365  UpdateLabelSizeRequest();
366}
367