src/chrome/browser/ui/gtk/bubble/bubble_gtk.cc

   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 #include "chrome/browser/ui/gtk/bubble/bubble_gtk.h"
   6
   7 #include <gdk/gdkkeysyms.h>
   8
   9 #include "base/bind.h"
  10 #include "base/i18n/rtl.h"
  11 #include "base/message_loop/message_loop.h"
  12 #include "chrome/browser/chrome_notification_types.h"
  13 #include "chrome/browser/ui/gtk/bubble/bubble_accelerators_gtk.h"
  14 #include "chrome/browser/ui/gtk/gtk_theme_service.h"
  15 #include "chrome/browser/ui/gtk/gtk_util.h"
  16 #include "content/public/browser/notification_source.h"
  17 #include "ui/base/gtk/gtk_hig_constants.h"
  18 #include "ui/base/gtk/gtk_windowing.h"
  19 #include "ui/gfx/gtk_compat.h"
  20 #include "ui/gfx/gtk_util.h"
  21 #include "ui/gfx/path.h"
  22 #include "ui/gfx/rect.h"
  23
  24 namespace {
  25
  26 // The height of the arrow, and the width will be about twice the height.
  27 const int kArrowSize = 8;
  28
  29 // Number of pixels to the middle of the arrow from the close edge of the
  30 // window.
  31 const int kArrowX = 18;
  32
  33 // Number of pixels between the tip of the arrow and the region we're
  34 // pointing to.
  35 const int kArrowToContentPadding = -4;
  36
  37 // We draw flat diagonal corners, each corner is an NxN square.
  38 const int kCornerSize = 3;
  39
  40 // The amount of padding (in pixels) from the top of |toplevel_window_| to the
  41 // top of |window_| when fixed positioning is used.
  42 const int kFixedPositionPaddingEnd = 10;
  43 const int kFixedPositionPaddingTop = 5;
  44
  45 const GdkColor kBackgroundColor = GDK_COLOR_RGB(0xff, 0xff, 0xff);
  46 const GdkColor kFrameColor = GDK_COLOR_RGB(0x63, 0x63, 0x63);
  47
  48 // Helper functions that encapsulate arrow locations.
  49 bool HasArrow(BubbleGtk::FrameStyle frame_style) {
  50   return frame_style != BubbleGtk::FLOAT_BELOW_RECT &&
  51          frame_style != BubbleGtk::CENTER_OVER_RECT &&
  52          frame_style != BubbleGtk::FIXED_TOP_LEFT &&
  53          frame_style != BubbleGtk::FIXED_TOP_RIGHT;
  54 }
  55
  56 bool IsArrowLeft(BubbleGtk::FrameStyle frame_style) {
  57   return frame_style == BubbleGtk::ANCHOR_TOP_LEFT ||
  58          frame_style == BubbleGtk::ANCHOR_BOTTOM_LEFT;
  59 }
  60
  61 bool IsArrowMiddle(BubbleGtk::FrameStyle frame_style) {
  62   return frame_style == BubbleGtk::ANCHOR_TOP_MIDDLE ||
  63          frame_style == BubbleGtk::ANCHOR_BOTTOM_MIDDLE;
  64 }
  65
  66 bool IsArrowRight(BubbleGtk::FrameStyle frame_style) {
  67   return frame_style == BubbleGtk::ANCHOR_TOP_RIGHT ||
  68          frame_style == BubbleGtk::ANCHOR_BOTTOM_RIGHT;
  69 }
  70
  71 bool IsArrowTop(BubbleGtk::FrameStyle frame_style) {
  72   return frame_style == BubbleGtk::ANCHOR_TOP_LEFT ||
  73          frame_style == BubbleGtk::ANCHOR_TOP_MIDDLE ||
  74          frame_style == BubbleGtk::ANCHOR_TOP_RIGHT;
  75 }
  76
  77 bool IsArrowBottom(BubbleGtk::FrameStyle frame_style) {
  78   return frame_style == BubbleGtk::ANCHOR_BOTTOM_LEFT ||
  79          frame_style == BubbleGtk::ANCHOR_BOTTOM_MIDDLE ||
  80          frame_style == BubbleGtk::ANCHOR_BOTTOM_RIGHT;
  81 }
  82
  83 bool IsFixed(BubbleGtk::FrameStyle frame_style) {
  84   return frame_style == BubbleGtk::FIXED_TOP_LEFT ||
  85          frame_style == BubbleGtk::FIXED_TOP_RIGHT;
  86 }
  87
  88 BubbleGtk::FrameStyle AdjustFrameStyleForLocale(
  89     BubbleGtk::FrameStyle frame_style) {
  90   // Only RTL requires more work.
  91   if (!base::i18n::IsRTL())
  92     return frame_style;
  93
  94   switch (frame_style) {
  95     // These don't flip.
  96     case BubbleGtk::ANCHOR_TOP_MIDDLE:
  97     case BubbleGtk::ANCHOR_BOTTOM_MIDDLE:
  98     case BubbleGtk::FLOAT_BELOW_RECT:
  99     case BubbleGtk::CENTER_OVER_RECT:
 100       return frame_style;
 101
 102     // These do flip.
 103     case BubbleGtk::ANCHOR_TOP_LEFT:
 104       return BubbleGtk::ANCHOR_TOP_RIGHT;
 105
 106     case BubbleGtk::ANCHOR_TOP_RIGHT:
 107       return BubbleGtk::ANCHOR_TOP_LEFT;
 108
 109     case BubbleGtk::ANCHOR_BOTTOM_LEFT:
 110       return BubbleGtk::ANCHOR_BOTTOM_RIGHT;
 111
 112     case BubbleGtk::ANCHOR_BOTTOM_RIGHT:
 113       return BubbleGtk::ANCHOR_BOTTOM_LEFT;
 114
 115     case BubbleGtk::FIXED_TOP_LEFT:
 116       return BubbleGtk::FIXED_TOP_RIGHT;
 117
 118     case BubbleGtk::FIXED_TOP_RIGHT:
 119       return BubbleGtk::FIXED_TOP_LEFT;
 120   }
 121
 122   NOTREACHED();
 123   return BubbleGtk::ANCHOR_TOP_LEFT;
 124 }
 125
 126 }  // namespace
 127
 128 // static
 129 BubbleGtk* BubbleGtk::Show(GtkWidget* anchor_widget,
 130                            const gfx::Rect* rect,
 131                            GtkWidget* content,
 132                            FrameStyle frame_style,
 133                            int attribute_flags,
 134                            GtkThemeService* provider,
 135                            BubbleDelegateGtk* delegate) {
 136   BubbleGtk* bubble = new BubbleGtk(provider,
 137                                     AdjustFrameStyleForLocale(frame_style),
 138                                     attribute_flags);
 139   bubble->Init(anchor_widget, rect, content, attribute_flags);
 140   bubble->set_delegate(delegate);
 141   return bubble;
 142 }
 143
 144 BubbleGtk::BubbleGtk(GtkThemeService* provider,
 145                      FrameStyle frame_style,
 146                      int attribute_flags)
 147     : delegate_(NULL),
 148       window_(NULL),
 149       theme_service_(provider),
 150       accel_group_(gtk_accel_group_new()),
 151       toplevel_window_(NULL),
 152       anchor_widget_(NULL),
 153       mask_region_(NULL),
 154       requested_frame_style_(frame_style),
 155       actual_frame_style_(ANCHOR_TOP_LEFT),
 156       match_system_theme_(attribute_flags & MATCH_SYSTEM_THEME),
 157       grab_input_(attribute_flags & GRAB_INPUT),
 158       closed_by_escape_(false),
 159       weak_ptr_factory_(this) {}
 160
 161 BubbleGtk::~BubbleGtk() {
 162   // Notify the delegate that we're about to close.  This gives the chance
 163   // to save state / etc from the hosted widget before it's destroyed.
 164   if (delegate_)
 165     delegate_->BubbleClosing(this, closed_by_escape_);
 166
 167   g_object_unref(accel_group_);
 168   if (mask_region_)
 169     gdk_region_destroy(mask_region_);
 170 }
 171
 172 void BubbleGtk::Init(GtkWidget* anchor_widget,
 173                      const gfx::Rect* rect,
 174                      GtkWidget* content,
 175                      int attribute_flags) {
 176   // If there is a current grab widget (menu, other bubble, etc.), hide it.
 177   GtkWidget* current_grab_widget = gtk_grab_get_current();
 178   if (current_grab_widget)
 179     gtk_widget_hide(current_grab_widget);
 180
 181   DCHECK(!window_);
 182   anchor_widget_ = anchor_widget;
 183   toplevel_window_ = gtk_widget_get_toplevel(anchor_widget_);
 184   DCHECK(gtk_widget_is_toplevel(toplevel_window_));
 185   rect_ = rect ? *rect : gtk_util::WidgetBounds(anchor_widget);
 186
 187   // Using a TOPLEVEL window may cause placement issues with certain WMs but it
 188   // is necessary to be able to focus the window.
 189   window_ = gtk_window_new(attribute_flags & POPUP_WINDOW ?
 190                            GTK_WINDOW_POPUP : GTK_WINDOW_TOPLEVEL);
 191
 192   gtk_widget_set_app_paintable(window_, TRUE);
 193   // Resizing is handled by the program, not user.
 194   gtk_window_set_resizable(GTK_WINDOW(window_), FALSE);
 195
 196   if (!(attribute_flags & NO_ACCELERATORS)) {
 197     // Attach all of the accelerators to the bubble.
 198     for (BubbleAcceleratorsGtk::const_iterator
 199              i(BubbleAcceleratorsGtk::begin());
 200          i != BubbleAcceleratorsGtk::end();
 201          ++i) {
 202       gtk_accel_group_connect(accel_group_,
 203                               i->keyval,
 204                               i->modifier_type,
 205                               GtkAccelFlags(0),
 206                               g_cclosure_new(G_CALLBACK(&OnGtkAcceleratorThunk),
 207                                              this,
 208                                              NULL));
 209     }
 210     gtk_window_add_accel_group(GTK_WINDOW(window_), accel_group_);
 211   }
 212
 213   // |requested_frame_style_| is used instead of |actual_frame_style_| here
 214   // because |actual_frame_style_| is only correct after calling
 215   // |UpdateFrameStyle()|. Unfortunately, |UpdateFrameStyle()| requires knowing
 216   // the size of |window_| (which happens later on).
 217   int arrow_padding = HasArrow(requested_frame_style_) ? kArrowSize : 0;
 218   GtkWidget* alignment = gtk_alignment_new(0.0, 0.0, 1.0, 1.0);
 219   gtk_alignment_set_padding(GTK_ALIGNMENT(alignment), arrow_padding, 0, 0, 0);
 220
 221   gtk_container_add(GTK_CONTAINER(alignment), content);
 222   gtk_container_add(GTK_CONTAINER(window_), alignment);
 223
 224   // GtkWidget only exposes the bitmap mask interface.  Use GDK to more
 225   // efficently mask a GdkRegion.  Make sure the window is realized during
 226   // OnSizeAllocate, so the mask can be applied to the GdkWindow.
 227   gtk_widget_realize(window_);
 228
 229   UpdateFrameStyle(true);  // Force move and reshape.
 230   StackWindow();
 231
 232   gtk_widget_add_events(window_, GDK_BUTTON_PRESS_MASK);
 233
 234   // Connect during the bubbling phase so the border is always on top.
 235   signals_.ConnectAfter(window_, "expose-event",
 236                         G_CALLBACK(OnExposeThunk), this);
 237   signals_.Connect(window_, "size-allocate", G_CALLBACK(OnSizeAllocateThunk),
 238                    this);
 239   signals_.Connect(window_, "button-press-event",
 240                    G_CALLBACK(OnButtonPressThunk), this);
 241   signals_.Connect(window_, "destroy", G_CALLBACK(OnDestroyThunk), this);
 242   signals_.Connect(window_, "hide", G_CALLBACK(OnHideThunk), this);
 243   if (grab_input_) {
 244     signals_.Connect(window_, "grab-broken-event",
 245                      G_CALLBACK(OnGrabBrokenThunk), this);
 246   }
 247
 248   signals_.Connect(anchor_widget_, "destroy",
 249                    G_CALLBACK(OnAnchorDestroyThunk), this);
 250   // If the toplevel window is being used as the anchor, then the signals below
 251   // are enough to keep us positioned correctly.
 252   if (anchor_widget_ != toplevel_window_) {
 253     signals_.Connect(anchor_widget_, "size-allocate",
 254                      G_CALLBACK(OnAnchorAllocateThunk), this);
 255   }
 256
 257   signals_.Connect(toplevel_window_, "configure-event",
 258                    G_CALLBACK(OnToplevelConfigureThunk), this);
 259   signals_.Connect(toplevel_window_, "unmap-event",
 260                    G_CALLBACK(OnToplevelUnmapThunk), this);
 261
 262   gtk_widget_show_all(window_);
 263
 264   if (grab_input_)
 265     gtk_grab_add(window_);
 266   GrabPointerAndKeyboard();
 267
 268   registrar_.Add(this, chrome::NOTIFICATION_BROWSER_THEME_CHANGED,
 269                  content::Source<ThemeService>(theme_service_));
 270   theme_service_->InitThemesFor(this);
 271 }
 272
 273 // NOTE: This seems a bit overcomplicated, but it requires a bunch of careful
 274 // fudging to get the pixels rasterized exactly where we want them, the arrow to
 275 // have a 1 pixel point, etc.
 276 // TODO(deanm): Windows draws with Skia and uses some PNG images for the
 277 // corners.  This is a lot more work, but they get anti-aliasing.
 278 // static
 279 std::vector<GdkPoint> BubbleGtk::MakeFramePolygonPoints(
 280     FrameStyle frame_style,
 281     int width,
 282     int height,
 283     FrameType type) {
 284   using gtk_util::MakeBidiGdkPoint;
 285   std::vector<GdkPoint> points;
 286
 287   int top_arrow_size = IsArrowTop(frame_style) ? kArrowSize : 0;
 288   int bottom_arrow_size = IsArrowBottom(frame_style) ? kArrowSize : 0;
 289   bool on_left = IsArrowLeft(frame_style);
 290
 291   // If we're stroking the frame, we need to offset some of our points by 1
 292   // pixel.  We do this when we draw horizontal lines that are on the bottom or
 293   // when we draw vertical lines that are closer to the end (where "end" is the
 294   // right side for ANCHOR_TOP_LEFT).
 295   int y_off = type == FRAME_MASK ? 0 : -1;
 296   // We use this one for arrows located on the left.
 297   int x_off_l = on_left ? y_off : 0;
 298   // We use this one for RTL.
 299   int x_off_r = !on_left ? -y_off : 0;
 300
 301   // Top left corner.
 302   points.push_back(MakeBidiGdkPoint(
 303       x_off_r, top_arrow_size + kCornerSize - 1, width, on_left));
 304   points.push_back(MakeBidiGdkPoint(
 305       kCornerSize + x_off_r - 1, top_arrow_size, width, on_left));
 306
 307   // The top arrow.
 308   if (top_arrow_size) {
 309     int arrow_x = frame_style == ANCHOR_TOP_MIDDLE ? width / 2 : kArrowX;
 310     points.push_back(MakeBidiGdkPoint(
 311         arrow_x - top_arrow_size + x_off_r, top_arrow_size, width, on_left));
 312     points.push_back(MakeBidiGdkPoint(
 313         arrow_x + x_off_r, 0, width, on_left));
 314     points.push_back(MakeBidiGdkPoint(
 315         arrow_x + 1 + x_off_l, 0, width, on_left));
 316     points.push_back(MakeBidiGdkPoint(
 317         arrow_x + top_arrow_size + 1 + x_off_l, top_arrow_size,
 318         width, on_left));
 319   }
 320
 321   // Top right corner.
 322   points.push_back(MakeBidiGdkPoint(
 323       width - kCornerSize + 1 + x_off_l, top_arrow_size, width, on_left));
 324   points.push_back(MakeBidiGdkPoint(
 325       width + x_off_l, top_arrow_size + kCornerSize - 1, width, on_left));
 326
 327   // Bottom right corner.
 328   points.push_back(MakeBidiGdkPoint(
 329       width + x_off_l, height - bottom_arrow_size - kCornerSize,
 330       width, on_left));
 331   points.push_back(MakeBidiGdkPoint(
 332       width - kCornerSize + x_off_r, height - bottom_arrow_size + y_off,
 333       width, on_left));
 334
 335   // The bottom arrow.
 336   if (bottom_arrow_size) {
 337     int arrow_x = frame_style == ANCHOR_BOTTOM_MIDDLE ?
 338         width / 2 : kArrowX;
 339     points.push_back(MakeBidiGdkPoint(
 340         arrow_x + bottom_arrow_size + 1 + x_off_l,
 341         height - bottom_arrow_size + y_off,
 342         width,
 343         on_left));
 344     points.push_back(MakeBidiGdkPoint(
 345         arrow_x + 1 + x_off_l, height + y_off, width, on_left));
 346     points.push_back(MakeBidiGdkPoint(
 347         arrow_x + x_off_r, height + y_off, width, on_left));
 348     points.push_back(MakeBidiGdkPoint(
 349         arrow_x - bottom_arrow_size + x_off_r,
 350         height - bottom_arrow_size + y_off,
 351         width,
 352         on_left));
 353   }
 354
 355   // Bottom left corner.
 356   points.push_back(MakeBidiGdkPoint(
 357       kCornerSize + x_off_l, height -bottom_arrow_size + y_off,
 358       width, on_left));
 359   points.push_back(MakeBidiGdkPoint(
 360       x_off_r, height - bottom_arrow_size - kCornerSize, width, on_left));
 361
 362   return points;
 363 }
 364
 365 BubbleGtk::FrameStyle BubbleGtk::GetAllowedFrameStyle(
 366     FrameStyle preferred_style,
 367     int arrow_x,
 368     int arrow_y,
 369     int width,
 370     int height) {
 371   if (IsFixed(preferred_style))
 372     return preferred_style;
 373
 374   const int screen_width = gdk_screen_get_width(gdk_screen_get_default());
 375   const int screen_height = gdk_screen_get_height(gdk_screen_get_default());
 376
 377   // Choose whether to show the bubble above or below the specified location.
 378   const bool prefer_top_arrow = IsArrowTop(preferred_style) ||
 379              preferred_style == FLOAT_BELOW_RECT;
 380   // The bleed measures the amount of bubble that would be shown offscreen.
 381   const int top_arrow_bleed =
 382       std::max(height + kArrowSize + arrow_y - screen_height, 0);
 383   const int bottom_arrow_bleed = std::max(height + kArrowSize - arrow_y, 0);
 384
 385   FrameStyle frame_style_none = FLOAT_BELOW_RECT;
 386   FrameStyle frame_style_left = ANCHOR_TOP_LEFT;
 387   FrameStyle frame_style_middle = ANCHOR_TOP_MIDDLE;
 388   FrameStyle frame_style_right = ANCHOR_TOP_RIGHT;
 389   if ((prefer_top_arrow && (top_arrow_bleed > bottom_arrow_bleed)) ||
 390       (!prefer_top_arrow && (top_arrow_bleed >= bottom_arrow_bleed))) {
 391     frame_style_none = CENTER_OVER_RECT;
 392     frame_style_left = ANCHOR_BOTTOM_LEFT;
 393     frame_style_middle = ANCHOR_BOTTOM_MIDDLE;
 394     frame_style_right = ANCHOR_BOTTOM_RIGHT;
 395   }
 396
 397   if (!HasArrow(preferred_style))
 398     return frame_style_none;
 399
 400   if (IsArrowMiddle(preferred_style))
 401     return frame_style_middle;
 402
 403   // Choose whether to show the bubble left or right of the specified location.
 404   const bool prefer_left_arrow = IsArrowLeft(preferred_style);
 405   // The bleed measures the amount of bubble that would be shown offscreen.
 406   const int left_arrow_bleed =
 407       std::max(width + arrow_x - kArrowX - screen_width, 0);
 408   const int right_arrow_bleed = std::max(width - arrow_x - kArrowX, 0);
 409
 410   // Use the preferred location if it doesn't bleed more than the opposite side.
 411   return ((prefer_left_arrow && (left_arrow_bleed <= right_arrow_bleed)) ||
 412           (!prefer_left_arrow && (left_arrow_bleed < right_arrow_bleed))) ?
 413       frame_style_left : frame_style_right;
 414 }
 415
 416 bool BubbleGtk::UpdateFrameStyle(bool force_move_and_reshape) {
 417   if (!toplevel_window_ || !anchor_widget_)
 418     return false;
 419
 420   gint toplevel_x = 0, toplevel_y = 0;
 421   gdk_window_get_position(gtk_widget_get_window(toplevel_window_),
 422                           &toplevel_x, &toplevel_y);
 423   int offset_x, offset_y;
 424   gtk_widget_translate_coordinates(anchor_widget_, toplevel_window_,
 425                                    rect_.x(), rect_.y(), &offset_x, &offset_y);
 426
 427   FrameStyle old_frame_style = actual_frame_style_;
 428   GtkAllocation allocation;
 429   gtk_widget_get_allocation(window_, &allocation);
 430   actual_frame_style_ = GetAllowedFrameStyle(
 431       requested_frame_style_,
 432       toplevel_x + offset_x + (rect_.width() / 2),  // arrow_x
 433       toplevel_y + offset_y,
 434       allocation.width,
 435       allocation.height);
 436
 437   if (force_move_and_reshape || actual_frame_style_ != old_frame_style) {
 438     UpdateWindowShape();
 439     MoveWindow();
 440     // We need to redraw the entire window to repaint its border.
 441     gtk_widget_queue_draw(window_);
 442     return true;
 443   }
 444   return false;
 445 }
 446
 447 void BubbleGtk::UpdateWindowShape() {
 448   if (mask_region_) {
 449     gdk_region_destroy(mask_region_);
 450     mask_region_ = NULL;
 451   }
 452   GtkAllocation allocation;
 453   gtk_widget_get_allocation(window_, &allocation);
 454   std::vector<GdkPoint> points = MakeFramePolygonPoints(
 455       actual_frame_style_, allocation.width, allocation.height,
 456       FRAME_MASK);
 457   mask_region_ = gdk_region_polygon(&points[0],
 458                                     points.size(),
 459                                     GDK_EVEN_ODD_RULE);
 460
 461   GdkWindow* gdk_window = gtk_widget_get_window(window_);
 462   gdk_window_shape_combine_region(gdk_window, NULL, 0, 0);
 463   gdk_window_shape_combine_region(gdk_window, mask_region_, 0, 0);
 464 }
 465
 466 void BubbleGtk::MoveWindow() {
 467   if (!toplevel_window_ || !anchor_widget_)
 468     return;
 469
 470   gint toplevel_x = 0, toplevel_y = 0;
 471   gdk_window_get_position(gtk_widget_get_window(toplevel_window_),
 472                           &toplevel_x, &toplevel_y);
 473
 474   int offset_x, offset_y;
 475   gtk_widget_translate_coordinates(anchor_widget_, toplevel_window_,
 476                                    rect_.x(), rect_.y(), &offset_x, &offset_y);
 477
 478   gint screen_x = 0;
 479   if (IsFixed(actual_frame_style_)) {
 480     GtkAllocation toplevel_allocation;
 481     gtk_widget_get_allocation(toplevel_window_, &toplevel_allocation);
 482
 483     GtkAllocation bubble_allocation;
 484     gtk_widget_get_allocation(window_, &bubble_allocation);
 485
 486     int x_offset = actual_frame_style_ == FIXED_TOP_LEFT ?
 487         kFixedPositionPaddingEnd :
 488         toplevel_allocation.width - bubble_allocation.width -
 489             kFixedPositionPaddingEnd;
 490     screen_x = toplevel_x + x_offset;
 491   } else if (!HasArrow(actual_frame_style_) ||
 492              IsArrowMiddle(actual_frame_style_)) {
 493     GtkAllocation allocation;
 494     gtk_widget_get_allocation(window_, &allocation);
 495     screen_x =
 496         toplevel_x + offset_x + (rect_.width() / 2) - allocation.width / 2;
 497   } else if (IsArrowLeft(actual_frame_style_)) {
 498     screen_x = toplevel_x + offset_x + (rect_.width() / 2) - kArrowX;
 499   } else if (IsArrowRight(actual_frame_style_)) {
 500     GtkAllocation allocation;
 501     gtk_widget_get_allocation(window_, &allocation);
 502     screen_x = toplevel_x + offset_x + (rect_.width() / 2) -
 503                allocation.width + kArrowX;
 504   } else {
 505     NOTREACHED();
 506   }
 507
 508   gint screen_y = toplevel_y + offset_y + rect_.height();
 509   if (IsFixed(actual_frame_style_)) {
 510     screen_y = toplevel_y + kFixedPositionPaddingTop;
 511   } else if (IsArrowTop(actual_frame_style_) ||
 512              actual_frame_style_ == FLOAT_BELOW_RECT) {
 513     screen_y += kArrowToContentPadding;
 514   } else {
 515     GtkAllocation allocation;
 516     gtk_widget_get_allocation(window_, &allocation);
 517     screen_y -= allocation.height + kArrowToContentPadding;
 518   }
 519
 520   gtk_window_move(GTK_WINDOW(window_), screen_x, screen_y);
 521 }
 522
 523 void BubbleGtk::StackWindow() {
 524   // Stack our window directly above the toplevel window.
 525   if (toplevel_window_)
 526     ui::StackPopupWindow(window_, toplevel_window_);
 527 }
 528
 529 void BubbleGtk::Observe(int type,
 530                         const content::NotificationSource& source,
 531                         const content::NotificationDetails& details) {
 532   DCHECK_EQ(type, chrome::NOTIFICATION_BROWSER_THEME_CHANGED);
 533   if (theme_service_->UsingNativeTheme() && match_system_theme_) {
 534     gtk_widget_modify_bg(window_, GTK_STATE_NORMAL, NULL);
 535   } else {
 536     // Set the background color, so we don't need to paint it manually.
 537     gtk_widget_modify_bg(window_, GTK_STATE_NORMAL, &kBackgroundColor);
 538   }
 539 }
 540
 541 void BubbleGtk::StopGrabbingInput() {
 542   UngrabPointerAndKeyboard();
 543   if (!grab_input_)
 544     return;
 545   grab_input_ = false;
 546   gtk_grab_remove(window_);
 547 }
 548
 549 GtkWindow* BubbleGtk::GetNativeWindow() {
 550   return GTK_WINDOW(window_);
 551 }
 552
 553 void BubbleGtk::Close() {
 554   // We don't need to ungrab the pointer or keyboard here; the X server will
 555   // automatically do that when we destroy our window.
 556   DCHECK(window_);
 557   gtk_widget_destroy(window_);
 558   // |this| has been deleted, see OnDestroy.
 559 }
 560
 561 void BubbleGtk::SetPositionRelativeToAnchor(const gfx::Rect* rect) {
 562   rect_ = rect ? *rect : gtk_util::WidgetBounds(anchor_widget_);
 563   if (!UpdateFrameStyle(false))
 564     MoveWindow();
 565 }
 566
 567 void BubbleGtk::GrabPointerAndKeyboard() {
 568   GdkWindow* gdk_window = gtk_widget_get_window(window_);
 569
 570   // Install X pointer and keyboard grabs to make sure that we have the focus
 571   // and get all mouse and keyboard events until we're closed. As a hack, grab
 572   // the pointer even if |grab_input_| is false to prevent a weird error
 573   // rendering the bubble's frame. See
 574   // https://code.google.com/p/chromium/issues/detail?id=130820.
 575   GdkGrabStatus pointer_grab_status =
 576       gdk_pointer_grab(gdk_window,
 577                        TRUE,                   // owner_events
 578                        GDK_BUTTON_PRESS_MASK,  // event_mask
 579                        NULL,                   // confine_to
 580                        NULL,                   // cursor
 581                        GDK_CURRENT_TIME);
 582   if (pointer_grab_status != GDK_GRAB_SUCCESS) {
 583     // This will fail if someone else already has the pointer grabbed, but
 584     // there's not really anything we can do about that.
 585     DLOG(ERROR) << "Unable to grab pointer (status="
 586                 << pointer_grab_status << ")";
 587   }
 588
 589   // Only grab the keyboard input if |grab_input_| is true.
 590   if (grab_input_) {
 591     GdkGrabStatus keyboard_grab_status =
 592         gdk_keyboard_grab(gdk_window,
 593                           FALSE,  // owner_events
 594                           GDK_CURRENT_TIME);
 595     if (keyboard_grab_status != GDK_GRAB_SUCCESS) {
 596       DLOG(ERROR) << "Unable to grab keyboard (status="
 597                   << keyboard_grab_status << ")";
 598     }
 599   }
 600 }
 601
 602 void BubbleGtk::UngrabPointerAndKeyboard() {
 603   gdk_pointer_ungrab(GDK_CURRENT_TIME);
 604   if (grab_input_)
 605     gdk_keyboard_ungrab(GDK_CURRENT_TIME);
 606 }
 607
 608 gboolean BubbleGtk::OnGtkAccelerator(GtkAccelGroup* group,
 609                                      GObject* acceleratable,
 610                                      guint keyval,
 611                                      GdkModifierType modifier) {
 612   GdkEventKey msg;
 613   GdkKeymapKey* keys;
 614   gint n_keys;
 615
 616   switch (keyval) {
 617     case GDK_Escape:
 618       // Close on Esc and trap the accelerator
 619       closed_by_escape_ = true;
 620       Close();
 621       return TRUE;
 622     case GDK_w:
 623       // Close on C-w and forward the accelerator
 624       if (modifier & GDK_CONTROL_MASK) {
 625         gdk_keymap_get_entries_for_keyval(NULL,
 626                                           keyval,
 627                                           &keys,
 628                                           &n_keys);
 629         if (n_keys) {
 630           // Forward the accelerator to root window the bubble is anchored
 631           // to for further processing
 632           msg.type = GDK_KEY_PRESS;
 633           msg.window = gtk_widget_get_window(toplevel_window_);
 634           msg.send_event = TRUE;
 635           msg.time = GDK_CURRENT_TIME;
 636           msg.state = modifier | GDK_MOD2_MASK;
 637           msg.keyval = keyval;
 638           // length and string are deprecated and thus zeroed out
 639           msg.length = 0;
 640           msg.string = NULL;
 641           msg.hardware_keycode = keys[0].keycode;
 642           msg.group = keys[0].group;
 643           msg.is_modifier = 0;
 644
 645           g_free(keys);
 646
 647           gtk_main_do_event(reinterpret_cast<GdkEvent*>(&msg));
 648         } else {
 649           // This means that there isn't a h/w code for the keyval in the
 650           // current keymap, which is weird but possible if the keymap just
 651           // changed. This isn't a critical error, but might be indicative
 652           // of something off if it happens regularly.
 653           DLOG(WARNING) << "Found no keys for value " << keyval;
 654         }
 655         Close();
 656       }
 657       break;
 658     default:
 659       return FALSE;
 660   }
 661
 662   return TRUE;
 663 }
 664
 665 gboolean BubbleGtk::OnExpose(GtkWidget* widget, GdkEventExpose* expose) {
 666   // TODO(erg): This whole method will need to be rewritten in cairo.
 667   GdkDrawable* drawable = GDK_DRAWABLE(gtk_widget_get_window(window_));
 668   GdkGC* gc = gdk_gc_new(drawable);
 669   gdk_gc_set_rgb_fg_color(gc, &kFrameColor);
 670
 671   // Stroke the frame border.
 672   GtkAllocation allocation;
 673   gtk_widget_get_allocation(window_, &allocation);
 674   std::vector<GdkPoint> points = MakeFramePolygonPoints(
 675       actual_frame_style_, allocation.width, allocation.height,
 676       FRAME_STROKE);
 677   gdk_draw_polygon(drawable, gc, FALSE, &points[0], points.size());
 678
 679   // If |grab_input_| is false, pointer input has been grabbed as a hack in
 680   // |GrabPointerAndKeyboard()| to ensure that the polygon frame is drawn
 681   // correctly. Since the intention is not actually to grab the pointer, release
 682   // it now that the frame is drawn to prevent clicks from being missed. See
 683   // https://code.google.com/p/chromium/issues/detail?id=130820.
 684   if (!grab_input_)
 685     gdk_pointer_ungrab(GDK_CURRENT_TIME);
 686
 687   g_object_unref(gc);
 688   return FALSE;  // Propagate so our children paint, etc.
 689 }
 690
 691 // When our size is initially allocated or changed, we need to recompute
 692 // and apply our shape mask region.
 693 void BubbleGtk::OnSizeAllocate(GtkWidget* widget,
 694                                GtkAllocation* allocation) {
 695   if (!UpdateFrameStyle(false)) {
 696     UpdateWindowShape();
 697     MoveWindow();
 698   }
 699 }
 700
 701 gboolean BubbleGtk::OnButtonPress(GtkWidget* widget,
 702                                   GdkEventButton* event) {
 703   // If we got a click in our own window, that's okay (we need to additionally
 704   // check that it falls within our bounds, since we've grabbed the pointer and
 705   // some events that actually occurred in other windows will be reported with
 706   // respect to our window).
 707   GdkWindow* gdk_window = gtk_widget_get_window(window_);
 708   if (event->window == gdk_window &&
 709       (mask_region_ && gdk_region_point_in(mask_region_, event->x, event->y))) {
 710     return FALSE;  // Propagate.
 711   }
 712
 713   // Our content widget got a click.
 714   if (event->window != gdk_window &&
 715       gdk_window_get_toplevel(event->window) == gdk_window) {
 716     return FALSE;
 717   }
 718
 719   if (grab_input_) {
 720     // Otherwise we had a click outside of our window, close ourself.
 721     Close();
 722     return TRUE;
 723   }
 724
 725   return FALSE;
 726 }
 727
 728 gboolean BubbleGtk::OnDestroy(GtkWidget* widget) {
 729   // We are self deleting, we have a destroy signal setup to catch when we
 730   // destroy the widget manually, or the window was closed via X.  This will
 731   // delete the BubbleGtk object.
 732   delete this;
 733   return FALSE;  // Propagate.
 734 }
 735
 736 void BubbleGtk::OnHide(GtkWidget* widget) {
 737   gtk_widget_destroy(widget);
 738 }
 739
 740 gboolean BubbleGtk::OnGrabBroken(GtkWidget* widget,
 741                                  GdkEventGrabBroken* grab_broken) {
 742   // |grab_input_| may have been changed to false.
 743   if (!grab_input_)
 744     return FALSE;
 745
 746   // |grab_window| can be NULL.
 747   if (!grab_broken->grab_window)
 748     return FALSE;
 749
 750   gpointer user_data;
 751   gdk_window_get_user_data(grab_broken->grab_window, &user_data);
 752
 753   if (GTK_IS_WIDGET(user_data)) {
 754     signals_.Connect(GTK_WIDGET(user_data), "hide",
 755                      G_CALLBACK(OnForeshadowWidgetHideThunk), this);
 756   }
 757
 758   return FALSE;
 759 }
 760
 761 void BubbleGtk::OnForeshadowWidgetHide(GtkWidget* widget) {
 762   if (grab_input_)
 763     GrabPointerAndKeyboard();
 764
 765   signals_.DisconnectAll(widget);
 766 }
 767
 768 gboolean BubbleGtk::OnToplevelConfigure(GtkWidget* widget,
 769                                         GdkEventConfigure* event) {
 770   if (!UpdateFrameStyle(false))
 771     MoveWindow();
 772   StackWindow();
 773   return FALSE;
 774 }
 775
 776 gboolean BubbleGtk::OnToplevelUnmap(GtkWidget* widget, GdkEvent* event) {
 777   Close();
 778   return FALSE;
 779 }
 780
 781 void BubbleGtk::OnAnchorAllocate(GtkWidget* widget,
 782                                  GtkAllocation* allocation) {
 783   if (!UpdateFrameStyle(false))
 784     MoveWindow();
 785 }
 786
 787 void BubbleGtk::OnAnchorDestroy(GtkWidget* widget) {
 788   anchor_widget_ = NULL;
 789
 790   // Ctrl-W will first destroy the anchor, then call |this| back via
 791   // |accel_group_|. So that the callback |this| registered via |accel_group_|
 792   // doesn't run after |this| is destroyed, we delay this close (which, unlike
 793   // the accelerator callback, will be cancelled if |this| is destroyed).
 794   // http://crbug.com/286621
 795   base::MessageLoop::current()->PostTask(
 796       FROM_HERE,
 797       base::Bind(&BubbleGtk::Close, weak_ptr_factory_.GetWeakPtr()));
 798 }