GTK: Implement BlockedPopupContainerView for linux.

chrome/browser/tab_contents/tab_contents_view_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/tab_contents/tab_contents_view_gtk.h"
 
 #include <gdk/gdk.h>
 #include <gtk/gtk.h>
 
 #include "base/string_util.h"
 #include "base/gfx/point.h"
 #include "base/gfx/rect.h"
 #include "base/gfx/size.h"
 #include "build/build_config.h"
 #include "chrome/browser/download/download_shelf.h"
+#include "chrome/browser/gtk/blocked_popup_container_view_gtk.h"
 #include "chrome/browser/gtk/browser_window_gtk.h"
+#include "chrome/browser/gtk/gtk_floating_container.h"
 #include "chrome/browser/gtk/sad_tab_gtk.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/renderer_host/render_view_host_factory.h"
 #include "chrome/browser/renderer_host/render_widget_host_view_gtk.h"
 #include "chrome/browser/tab_contents/interstitial_page.h"
 #include "chrome/browser/tab_contents/render_view_context_menu_gtk.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/tab_contents/tab_contents_delegate.h"
 #include "chrome/common/gtk_util.h"
 #include "chrome/common/notification_source.h"
 #include "chrome/common/notification_type.h"
 
 namespace {
 
+// TODO(erg): I have no idea how to progromatically figure out how wide the
+// vertical scrollbar is. Hack it with a hardcoded value for now.
+const int kScrollbarWidthHack = 25;
+
 // Called when the content view gtk widget is tabbed to, or after the call to
 // gtk_widget_child_focus() in TakeFocus(). We return true
 // and grab focus if we don't have it. The call to
 // FocusThroughTabTraversal(bool) forwards the "move focus forward" effect to
 // webkit.
 gboolean OnFocus(GtkWidget* widget, GtkDirectionType focus,
                  TabContents* tab_contents) {
   // If we already have focus, let the next widget have a shot at it. We will
   // reach this situation after the call to gtk_widget_child_focus() in
   // TakeFocus().
@@ skipping 51 matching lines @@
 
 }  // namespace
 
 // static
 TabContentsView* TabContentsView::Create(TabContents* tab_contents) {
   return new TabContentsViewGtk(tab_contents);
 }
 
 TabContentsViewGtk::TabContentsViewGtk(TabContents* tab_contents)
     : TabContentsView(tab_contents),
-      fixed_(gtk_fixed_new()) {
-  g_signal_connect(fixed_.get(), "size-allocate",
+      floating_(gtk_floating_container_new()),
+      fixed_(gtk_fixed_new()),
+      popup_view_(NULL) {
+  g_signal_connect(fixed_, "size-allocate",
                    G_CALLBACK(OnSizeAllocate), this);
-  gtk_widget_show(fixed_.get());
+  g_signal_connect(floating_.get(), "set-floating-position",
+                   G_CALLBACK(OnSetFloatingPosition), this);
+
+  gtk_container_add(GTK_CONTAINER(floating_.get()), fixed_);
+  gtk_widget_show(fixed_);
+  gtk_widget_show(floating_.get());
   registrar_.Add(this, NotificationType::TAB_CONTENTS_CONNECTED,
                  Source<TabContents>(tab_contents));
 }
 
 TabContentsViewGtk::~TabContentsViewGtk() {
-  fixed_.Destroy();
+  floating_.Destroy();
+}
+
+void TabContentsViewGtk::AttachBlockedPopupView(
+    BlockedPopupContainerViewGtk* popup_view) {
+  DCHECK(popup_view_ == NULL);
+  popup_view_ = popup_view;
+  gtk_floating_container_add_floating(GTK_FLOATING_CONTAINER(floating_.get()),
+                                      popup_view->widget());
+}
+
+void TabContentsViewGtk::RemoveBlockedPopupView(
+    BlockedPopupContainerViewGtk* popup_view) {
+  DCHECK(popup_view_ == popup_view);
+  gtk_container_remove(GTK_CONTAINER(floating_.get()), popup_view->widget());
+  popup_view_ = NULL;
 }
 
 void TabContentsViewGtk::CreateView() {
   // Windows uses this to do initialization, but we do all our initialization
   // in the constructor.
 }
 
 RenderWidgetHostView* TabContentsViewGtk::CreateViewForWidget(
     RenderWidgetHost* render_widget_host) {
   if (render_widget_host->view()) {
@@ skipping 21 matching lines @@
   gtk_widget_add_events(content_view, GDK_LEAVE_NOTIFY_MASK |
                         GDK_POINTER_MOTION_MASK);
   g_signal_connect(content_view, "button-press-event",
                    G_CALLBACK(OnMouseDown), this);
 
   InsertIntoContentArea(content_view);
   return view;
 }
 
 gfx::NativeView TabContentsViewGtk::GetNativeView() const {
-  return fixed_.get();
+  return floating_.get();
 }
 
 gfx::NativeView TabContentsViewGtk::GetContentNativeView() const {
   if (!tab_contents()->render_widget_host_view())
     return NULL;
   return tab_contents()->render_widget_host_view()->GetNativeView();
 }
 
 
 gfx::NativeWindow TabContentsViewGtk::GetTopLevelNativeWindow() const {
   GtkWidget* window = gtk_widget_get_ancestor(GetNativeView(), GTK_TYPE_WINDOW);
   return window ? GTK_WINDOW(window) : NULL;
 }
 
 void TabContentsViewGtk::GetContainerBounds(gfx::Rect* out) const {
   // This is used for positioning the download shelf arrow animation,
   // as well as sizing some other widgets in Windows.  In GTK the size is
   // managed for us, so it appears to be only used for the download shelf
   // animation.
   int x = 0;
   int y = 0;
-  if (fixed_.get()->window)
-    gdk_window_get_origin(fixed_.get()->window, &x, &y);
-  out->SetRect(x + fixed_.get()->allocation.x, y + fixed_.get()->allocation.y,
-               fixed_.get()->allocation.width, fixed_.get()->allocation.height);
+  if (fixed_->window)
+    gdk_window_get_origin(fixed_->window, &x, &y);
+  out->SetRect(x + fixed_->allocation.x, y + fixed_->allocation.y,
+               fixed_->allocation.width, fixed_->allocation.height);
 }
 
 void TabContentsViewGtk::OnContentsDestroy() {
   // TODO(estade): Windows uses this function cancel pending drag-n-drop drags.
   // We don't have drags yet, so do nothing for now.
 }
 
 void TabContentsViewGtk::SetPageTitle(const std::wstring& title) {
   // Set the window name to include the page title so it's easier to spot
   // when debugging (e.g. via xwininfo -tree).
@@ skipping 103 matching lines @@
 
   // Until we have d'n'd implemented, just immediately pretend we're
   // already done with the drag and drop so we don't get stuck
   // thinking we're in mid-drag.
   // TODO(port): remove me when the above NOTIMPLEMENTED is fixed.
   if (tab_contents()->render_view_host())
     tab_contents()->render_view_host()->DragSourceSystemDragEnded();
 }
 
 void TabContentsViewGtk::InsertIntoContentArea(GtkWidget* widget) {
-  gtk_fixed_put(GTK_FIXED(fixed_.get()), widget, 0, 0);
+  gtk_fixed_put(GTK_FIXED(fixed_), widget, 0, 0);
 }
 
 gboolean TabContentsViewGtk::OnMouseDown(GtkWidget* widget,
     GdkEventButton* event, TabContentsViewGtk* view) {
   view->last_mouse_down_time_ = event->time;
   return FALSE;
 }
 
 gboolean TabContentsViewGtk::OnSizeAllocate(GtkWidget* widget,
                                             GtkAllocation* allocation,
                                             TabContentsViewGtk* view) {
   int width = allocation->width;
   int height = allocation->height;
   // |delegate()| can be NULL here during browser teardown.
   if (view->tab_contents()->delegate())
     height += view->tab_contents()->delegate()->GetExtraRenderViewHeight();
   gfx::Size size(width, height);
   gtk_container_foreach(GTK_CONTAINER(widget), SetSizeRequest, &size);
 
   return FALSE;
 }
+
+// static
+void TabContentsViewGtk::OnSetFloatingPosition(
+    GtkFloatingContainer* floating_container, GtkAllocation* allocation,
+    TabContentsViewGtk* tab_contents_view) {
+  if (tab_contents_view->popup_view_) {
+    GtkWidget* widget = tab_contents_view->popup_view_->widget();
+
+    // Look at the size request of the status bubble and tell the
+    // GtkFloatingContainer where we want it positioned.
+    GtkRequisition requisition;
+    gtk_widget_size_request(widget, &requisition);
+
+    GValue value = { 0, };
+    g_value_init(&value, G_TYPE_INT);
+
+    int child_x = std::max(
+        allocation->x + allocation->width - requisition.width -
+        kScrollbarWidthHack, 0);
+    g_value_set_int(&value, child_x);
+    gtk_container_child_set_property(GTK_CONTAINER(floating_container),
+                                     widget, "x", &value);
+
+    int child_y = std::max(
+        allocation->y + allocation->height - requisition.height, 0);
+    g_value_set_int(&value, child_y);
+    gtk_container_child_set_property(GTK_CONTAINER(floating_container),
+                                     widget, "y", &value);
+    g_value_unset(&value);
+  }
+}