GTK: Try to position info bubbles onscreen.

chrome/browser/gtk/info_bubble_gtk.h

 // 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.
 
 // This is the GTK implementation of InfoBubbles.  InfoBubbles are like
 // dialogs, but they point to a given element on the screen.  You should call
 // InfoBubbleGtk::Show, which will create and display a bubble.  The object is
 // self deleting, when the bubble is closed, you will be notified via
 // InfoBubbleGtkDelegate::InfoBubbleClosing().  Then the widgets and the
 // underlying object will be destroyed.  You can also close and destroy the
@@ skipping 54 matching lines @@
   // grabs (e.g. GtkComboBox), this method should be called after a widget
   // releases the grabs so we can reacquire them.  Note that this causes a race
   // condition; another client could grab them before we do (ideally, GDK would
   // transfer the grabs back to us when the widget releases them).  The window
   // is small, though, and the worst-case scenario for this seems to just be
   // that the content's widgets will appear inactive even after the user clicks
   // in them.
   void HandlePointerAndKeyboardUngrabbedByContent();
 
  private:
+  // Where should the arrow be placed relative to the bubble?
+  enum ArrowLocationGtk {
+    // TODO(derat): Support placing arrows on the bottoms of the bubbles.
+    ARROW_LOCATION_TOP_LEFT,
+    ARROW_LOCATION_TOP_RIGHT,
+  };
+
+  enum FrameType {
+    FRAME_MASK,
+    FRAME_STROKE,
+  };
+
   explicit InfoBubbleGtk(GtkThemeProvider* provider);
   virtual ~InfoBubbleGtk();
 
   // Creates the InfoBubble.
   void Init(GtkWindow* toplevel_window,
             const gfx::Rect& rect,
             GtkWidget* content);
 
+  // Make the points for our polygon frame, either for fill (the mask), or for
+  // when we stroke the border.
+  static std::vector<GdkPoint> MakeFramePolygonPoints(
+      ArrowLocationGtk arrow_location,
+      int width,
+      int height,
+      FrameType type);
+
+  // Get the location where the arrow should be placed (which is a function of
+  // whether the user's language is LTR/RTL and of the direction that the bubble
+  // should be facing to fit onscreen).  |arrow_x| is the X component in screen
+  // coordinates of the point at which the bubble's arrow should be aimed, and
+  // |width| is the bubble's width.
+  static ArrowLocationGtk GetArrowLocation(int arrow_x, int width);
+
+  // Updates |arrow_location_| based on the toplevel window's current position
+  // and the bubble's size.  If the location changes, moves and reshapes the
+  // window and returns true.
+  bool UpdateArrowLocation();
+
+  // Reshapes the window and updates |mask_region_|.
+  void UpdateWindowShape();
+
   // Calculate the current screen position for the bubble's window (per
   // |toplevel_window_|'s position as of its most-recent ConfigureNotify event
   // and |rect_|) and move it there.
   void MoveWindow();
 
   // Restack the bubble's window directly above |toplevel_window_|.
   void StackWindow();
 
   // Sets the delegate.
   void set_delegate(InfoBubbleGtkDelegate* delegate) { delegate_ = delegate; }
 
   // Closes the window and notifies the delegate. |closed_by_escape| is true if
   // the close is the result of pressing escape.
   void CloseInternal(bool closed_by_escape);
 
   // Grab (in the X sense) the pointer and keyboard.  This is needed to make
   // sure that we have the input focus.
   void GrabPointerAndKeyboard();
 
   static gboolean HandleEscapeThunk(GtkAccelGroup* group,
                                     GObject* acceleratable,
                                     guint keyval,
                                     GdkModifierType modifier,
                                     gpointer user_data) {
     return reinterpret_cast<InfoBubbleGtk*>(user_data)->HandleEscape();
   }
   gboolean HandleEscape();
 
+  static gboolean HandleExposeThunk(GtkWidget* widget,
+                                    GdkEventExpose* event,
+                                    gpointer user_data) {
+    return reinterpret_cast<InfoBubbleGtk*>(user_data)->HandleExpose();
+  }
+  gboolean HandleExpose();
+
   static void HandleSizeAllocateThunk(GtkWidget* widget,
                                       GtkAllocation* allocation,
                                       gpointer user_data) {
     reinterpret_cast<InfoBubbleGtk*>(user_data)->HandleSizeAllocate();
   }
   void HandleSizeAllocate();
 
   static gboolean HandleButtonPressThunk(GtkWidget* widget,
                                          GdkEventButton* event,
                                          gpointer user_data) {
@@ skipping 48 matching lines @@
   GtkWindow* toplevel_window_;
 
   // Provides an offset from |toplevel_window_|'s origin for MoveWindow() to
   // use.
   gfx::Rect rect_;
 
   // The current shape of |window_| (used to test whether clicks fall in it or
   // not).
   GdkRegion* mask_region_;
 
+  // Where should the arrow be drawn relative to the bubble?
+  ArrowLocationGtk arrow_location_;
+
   NotificationRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(InfoBubbleGtk);
 };
 
 #endif  // CHROME_BROWSER_GTK_INFO_BUBBLE_GTK_H_