GTK: Fix browser action bubble arrow positions.

chrome/browser/gtk/info_bubble_gtk.cc

 // Copyright (c) 2009 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/gtk/info_bubble_gtk.h"
 
 #include <gdk/gdkkeysyms.h>
 #include <gtk/gtk.h>
 
 #include "app/gfx/gtk_util.h"
@@ skipping 29 matching lines @@
 
 const GdkColor kBackgroundColor = GDK_COLOR_RGB(0xff, 0xff, 0xff);
 const GdkColor kFrameColor = GDK_COLOR_RGB(0x63, 0x63, 0x63);
 
 }  // namespace
 
 // static
 InfoBubbleGtk* InfoBubbleGtk::Show(GtkWindow* toplevel_window,
                                    const gfx::Rect& rect,
                                    GtkWidget* content,
+                                   ArrowLocationGtk arrow_location,
                                    GtkThemeProvider* provider,
                                    InfoBubbleGtkDelegate* delegate) {
   InfoBubbleGtk* bubble = new InfoBubbleGtk(provider);
-  bubble->Init(toplevel_window, rect, content);
+  bubble->Init(toplevel_window, rect, content, arrow_location);
   bubble->set_delegate(delegate);
   return bubble;
 }
 
 InfoBubbleGtk::InfoBubbleGtk(GtkThemeProvider* provider)
     : delegate_(NULL),
       window_(NULL),
       theme_provider_(provider),
       accel_group_(gtk_accel_group_new()),
       toplevel_window_(NULL),
       mask_region_(NULL),
-      arrow_location_(ARROW_LOCATION_TOP_LEFT) {
+      preferred_arrow_location_(ARROW_LOCATION_TOP_LEFT),
+      current_arrow_location_(ARROW_LOCATION_TOP_LEFT) {
 }
 
 InfoBubbleGtk::~InfoBubbleGtk() {
   g_object_unref(accel_group_);
   if (mask_region_) {
     gdk_region_destroy(mask_region_);
     mask_region_ = NULL;
   }
 
   g_signal_handlers_disconnect_by_func(
       toplevel_window_,
       reinterpret_cast<gpointer>(HandleToplevelConfigureThunk),
       this);
   g_signal_handlers_disconnect_by_func(
       toplevel_window_,
       reinterpret_cast<gpointer>(HandleToplevelUnmapThunk),
       this);
   toplevel_window_ = NULL;
 }
 
 void InfoBubbleGtk::Init(GtkWindow* toplevel_window,
                          const gfx::Rect& rect,
-                         GtkWidget* content) {
+                         GtkWidget* content,
+                         ArrowLocationGtk arrow_location) {
   DCHECK(!window_);
   toplevel_window_ = toplevel_window;
   rect_ = rect;
+  preferred_arrow_location_ = arrow_location;
 
   window_ = gtk_window_new(GTK_WINDOW_POPUP);
   gtk_widget_set_app_paintable(window_, TRUE);
 
   // Attach our accelerator group to the window with an escape accelerator.
   gtk_accel_group_connect(accel_group_, GDK_Escape,
       static_cast<GdkModifierType>(0), static_cast<GtkAccelFlags>(0),
       g_cclosure_new(G_CALLBACK(&HandleEscapeThunk), this, NULL));
   gtk_window_add_accel_group(GTK_WINDOW(window_), accel_group_);
 
   GtkWidget* alignment = gtk_alignment_new(0.0, 0.0, 1.0, 1.0);
   gtk_alignment_set_padding(GTK_ALIGNMENT(alignment),
                             kTopMargin, kBottomMargin,
                             kLeftMargin, kRightMargin);
 
   gtk_container_add(GTK_CONTAINER(alignment), content);
   gtk_container_add(GTK_CONTAINER(window_), alignment);
 
   // GtkWidget only exposes the bitmap mask interface.  Use GDK to more
   // efficently mask a GdkRegion.  Make sure the window is realized during
   // HandleSizeAllocate, so the mask can be applied to the GdkWindow.
   gtk_widget_realize(window_);
 
-  // For RTL, we will have to move the window again when it is allocated, but
-  // this should be somewhat close to its final position.
-  MoveWindow();
-  GtkRequisition req;
-  gtk_widget_size_request(window_, &req);
-
+  UpdateArrowLocation(true);  // Force move and reshape.
   StackWindow();
 
   gtk_widget_add_events(window_, GDK_BUTTON_PRESS_MASK |
                                  GDK_BUTTON_RELEASE_MASK);
 
   g_signal_connect(window_, "expose-event",
                    G_CALLBACK(HandleExposeThunk), this);
   g_signal_connect(window_, "size-allocate",
                    G_CALLBACK(HandleSizeAllocateThunk), this);
   g_signal_connect(window_, "button-press-event",
@@ skipping 38 matching lines @@
 // corners.  This is a lot more work, but they get anti-aliasing.
 // static
 std::vector<GdkPoint> InfoBubbleGtk::MakeFramePolygonPoints(
     ArrowLocationGtk arrow_location,
     int width,
     int height,
     FrameType type) {
   using gtk_util::MakeBidiGdkPoint;
   std::vector<GdkPoint> points;
 
-  // This name isn't completely accurate; the arrow location can differ from its
-  // expected location for LTR/RTL if needed for the bubble to fit onscreen.
-  bool ltr = (arrow_location == ARROW_LOCATION_TOP_LEFT);
+  bool on_left = (arrow_location == ARROW_LOCATION_TOP_LEFT);
 
-  // If we have a stroke, we have to offset some of our points by 1 pixel.
-  // We have to inset by 1 pixel when we draw horizontal lines that are on the
-  // bottom or when we draw vertical lines that are closer to the end (end is
-  // right for ltr).
+  // If we're stroking the frame, we need to offset some of our points by 1
+  // pixel.  We do this when we draw horizontal lines that are on the bottom or
+  // when we draw vertical lines that are closer to the end (where "end" is the
+  // right side for ARROW_LOCATION_TOP_LEFT).
   int y_off = (type == FRAME_MASK) ? 0 : -1;
-  // We use this one for LTR.
-  int x_off_l = ltr ? y_off : 0;
+  // We use this one for arrows located on the left.
+  int x_off_l = on_left ? y_off : 0;
   // We use this one for RTL.
-  int x_off_r = !ltr ? -y_off : 0;
+  int x_off_r = !on_left ? -y_off : 0;
 
   // Top left corner.
   points.push_back(MakeBidiGdkPoint(
-      x_off_r, kArrowSize + kCornerSize - 1, width, ltr));
+      x_off_r, kArrowSize + kCornerSize - 1, width, on_left));
   points.push_back(MakeBidiGdkPoint(
-      kCornerSize + x_off_r - 1, kArrowSize, width, ltr));
+      kCornerSize + x_off_r - 1, kArrowSize, width, on_left));
 
   // The arrow.
   points.push_back(MakeBidiGdkPoint(
-      kArrowX - kArrowSize + x_off_r, kArrowSize, width, ltr));
+      kArrowX - kArrowSize + x_off_r, kArrowSize, width, on_left));
   points.push_back(MakeBidiGdkPoint(
-      kArrowX + x_off_r, 0, width, ltr));
+      kArrowX + x_off_r, 0, width, on_left));
   points.push_back(MakeBidiGdkPoint(
-      kArrowX + 1 + x_off_l, 0, width, ltr));
+      kArrowX + 1 + x_off_l, 0, width, on_left));
   points.push_back(MakeBidiGdkPoint(
-      kArrowX + kArrowSize + 1 + x_off_l, kArrowSize, width, ltr));
+      kArrowX + kArrowSize + 1 + x_off_l, kArrowSize, width, on_left));
 
   // Top right corner.
   points.push_back(MakeBidiGdkPoint(
-      width - kCornerSize + 1 + x_off_l, kArrowSize, width, ltr));
+      width - kCornerSize + 1 + x_off_l, kArrowSize, width, on_left));
   points.push_back(MakeBidiGdkPoint(
-      width + x_off_l, kArrowSize + kCornerSize - 1, width, ltr));
+      width + x_off_l, kArrowSize + kCornerSize - 1, width, on_left));
 
   // Bottom right corner.
   points.push_back(MakeBidiGdkPoint(
-      width + x_off_l, height - kCornerSize, width, ltr));
+      width + x_off_l, height - kCornerSize, width, on_left));
   points.push_back(MakeBidiGdkPoint(
-      width - kCornerSize + x_off_r, height + y_off, width, ltr));
+      width - kCornerSize + x_off_r, height + y_off, width, on_left));
 
   // Bottom left corner.
   points.push_back(MakeBidiGdkPoint(
-      kCornerSize + x_off_l, height + y_off, width, ltr));
+      kCornerSize + x_off_l, height + y_off, width, on_left));
   points.push_back(MakeBidiGdkPoint(
-      x_off_r, height - kCornerSize, width, ltr));
+      x_off_r, height - kCornerSize, width, on_left));
 
   return points;
 }
 
 InfoBubbleGtk::ArrowLocationGtk InfoBubbleGtk::GetArrowLocation(
-    int arrow_x, int width) {
-  bool ltr = (l10n_util::GetTextDirection() == l10n_util::LEFT_TO_RIGHT);
+    ArrowLocationGtk preferred_location, int arrow_x, int width) {
+  bool wants_left = (preferred_location == ARROW_LOCATION_TOP_LEFT);
   int screen_width = gdk_screen_get_width(gdk_screen_get_default());
 
   bool left_is_onscreen = (arrow_x - kArrowX + width < screen_width);
   bool right_is_onscreen = (arrow_x + kArrowX - width >= 0);
 
-  // Use the expected location for our LTR/RTL-ness if it fits onscreen, use
-  // whatever fits otherwise, and use the expected location if neither fits.
-  if (left_is_onscreen && (ltr || !right_is_onscreen))
+  // Use the requested location if it fits onscreen, use whatever fits
+  // otherwise, and use the requested location if neither fits.
+  if (left_is_onscreen && (wants_left || !right_is_onscreen))
     return ARROW_LOCATION_TOP_LEFT;
-  if (right_is_onscreen && (!ltr || !left_is_onscreen))
+  if (right_is_onscreen && (!wants_left || !left_is_onscreen))
     return ARROW_LOCATION_TOP_RIGHT;
-  return (ltr ? ARROW_LOCATION_TOP_LEFT : ARROW_LOCATION_TOP_RIGHT);
+  return (wants_left ? ARROW_LOCATION_TOP_LEFT : ARROW_LOCATION_TOP_RIGHT);
 }
 
-bool InfoBubbleGtk::UpdateArrowLocation() {
+bool InfoBubbleGtk::UpdateArrowLocation(bool force_move_and_reshape) {
   gint toplevel_x = 0, toplevel_y = 0;
   gdk_window_get_position(
       GTK_WIDGET(toplevel_window_)->window, &toplevel_x, &toplevel_y);
 
-  ArrowLocationGtk old_location = arrow_location_;
-  arrow_location_ = GetArrowLocation(
+  ArrowLocationGtk old_location = current_arrow_location_;
+  current_arrow_location_ = GetArrowLocation(
+      preferred_arrow_location_,
       toplevel_x + rect_.x() + (rect_.width() / 2),  // arrow_x
       window_->allocation.width);
 
-  if (arrow_location_ != old_location) {
+  if (force_move_and_reshape || current_arrow_location_ != old_location) {
     UpdateWindowShape();
     MoveWindow();
     // We need to redraw the entire window to repaint its border.
     gtk_widget_queue_draw(window_);
     return true;
   }
   return false;
 }
 
 void InfoBubbleGtk::UpdateWindowShape() {
   if (mask_region_) {
     gdk_region_destroy(mask_region_);
     mask_region_ = NULL;
   }
   std::vector<GdkPoint> points = MakeFramePolygonPoints(
-      arrow_location_, window_->allocation.width, window_->allocation.height,
+      current_arrow_location_,
+      window_->allocation.width, window_->allocation.height,
       FRAME_MASK);
   mask_region_ = gdk_region_polygon(&points[0],
                                     points.size(),
                                     GDK_EVEN_ODD_RULE);
   gdk_window_shape_combine_region(window_->window, mask_region_, 0, 0);
 }
 
 void InfoBubbleGtk::MoveWindow() {
   gint toplevel_x = 0, toplevel_y = 0;
   gdk_window_get_position(
       GTK_WIDGET(toplevel_window_)->window, &toplevel_x, &toplevel_y);
 
   gint screen_x = 0;
-  if (arrow_location_ == ARROW_LOCATION_TOP_LEFT) {
+  if (current_arrow_location_ == ARROW_LOCATION_TOP_LEFT) {
     screen_x = toplevel_x + rect_.x() + (rect_.width() / 2) - kArrowX;
-  } else if (arrow_location_ == ARROW_LOCATION_TOP_RIGHT) {
+  } else if (current_arrow_location_ == ARROW_LOCATION_TOP_RIGHT) {
     screen_x = toplevel_x + rect_.x() + (rect_.width() / 2) -
                window_->allocation.width + kArrowX;
   } else {
     NOTREACHED();
   }
 
   gint screen_y = toplevel_y + rect_.y() + rect_.height() +
                   kArrowToContentPadding;
 
   gtk_window_move(GTK_WINDOW(window_), screen_x, screen_y);
@@ skipping 65 matching lines @@
   return TRUE;
 }
 
 gboolean InfoBubbleGtk::HandleExpose() {
   GdkDrawable* drawable = GDK_DRAWABLE(window_->window);
   GdkGC* gc = gdk_gc_new(drawable);
   gdk_gc_set_rgb_fg_color(gc, &kFrameColor);
 
   // Stroke the frame border.
   std::vector<GdkPoint> points = MakeFramePolygonPoints(
-      arrow_location_, window_->allocation.width, window_->allocation.height,
+      current_arrow_location_,
+      window_->allocation.width, window_->allocation.height,
       FRAME_STROKE);
   gdk_draw_polygon(drawable, gc, FALSE, &points[0], points.size());
 
   g_object_unref(gc);
   return FALSE;  // Propagate so our children paint, etc.
 }
 
 // When our size is initially allocated or changed, we need to recompute
 // and apply our shape mask region.
 void InfoBubbleGtk::HandleSizeAllocate() {
-  if (!UpdateArrowLocation()) {
+  if (!UpdateArrowLocation(false)) {
     UpdateWindowShape();
-    if (arrow_location_ == ARROW_LOCATION_TOP_RIGHT)
+    if (current_arrow_location_ == ARROW_LOCATION_TOP_RIGHT)
       MoveWindow();
   }
 }
 
 gboolean InfoBubbleGtk::HandleButtonPress(GdkEventButton* event) {
   // If we got a click in our own window, that's okay (we need to additionally
   // check that it falls within our bounds, since we've grabbed the pointer and
   // some events that actually occurred in other windows will be reported with
   // respect to our window).
   if (event->window == window_->window &&
@@ skipping 14 matching lines @@
 
 gboolean InfoBubbleGtk::HandleDestroy() {
   // We are self deleting, we have a destroy signal setup to catch when we
   // destroy the widget manually, or the window was closed via X.  This will
   // delete the InfoBubbleGtk object.
   delete this;
   return FALSE;  // Propagate.
 }
 
 gboolean InfoBubbleGtk::HandleToplevelConfigure(GdkEventConfigure* event) {
-  if (!UpdateArrowLocation())
+  if (!UpdateArrowLocation(false))
     MoveWindow();
   StackWindow();
   return FALSE;
 }
 
 gboolean InfoBubbleGtk::HandleToplevelUnmap() {
   Close();
   return FALSE;
 }