Creates a new TabContentsViewGtk for views based FE.

views/widget/widget_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 "views/widget/widget_gtk.h"
 
 #include "app/gfx/path.h"
 #include "base/compiler_specific.h"
 #include "views/fill_layout.h"
 #include "views/widget/default_theme_provider.h"
@@ skipping 35 matching lines @@
       break;
     default:
       // We only deal with 1-3.
       break;
   }
   if (event.type == GDK_2BUTTON_PRESS)
     flags |= MouseEvent::EF_IS_DOUBLE_CLICK;
   return flags;
 }
 
+// static
+GtkWidget* WidgetGtk::null_parent_ = NULL;
+
 ////////////////////////////////////////////////////////////////////////////////
 // WidgetGtk, public:
 
 WidgetGtk::WidgetGtk(Type type)
     : is_window_(false),
       type_(type),
       widget_(NULL),
-      child_widget_parent_(NULL),
+      window_contents_(NULL),
       is_mouse_down_(false),
       has_capture_(false),
       last_mouse_event_was_move_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(close_widget_factory_(this)),
       delete_on_destroy_(true),
       transparent_(false) {
 }
 
 WidgetGtk::~WidgetGtk() {
   MessageLoopForUI::current()->RemoveObserver(this);
 }
 
 void WidgetGtk::Init(GtkWidget* parent,
                      const gfx::Rect& bounds,
                      bool has_own_focus_manager) {
   // Force creation of the RootView if it hasn't been created yet.
   GetRootView();
 
 #if !defined(LINUX2)
   default_theme_provider_.reset(new DefaultThemeProvider());
 #endif
 
   // Make container here.
-  CreateGtkWidget();
+  CreateGtkWidget(parent);
 
   // Make sure we receive our motion events.
 
   // In general we register most events on the parent of all widgets. At a
   // minimum we need painting to happen on the parent (otherwise painting
   // doesn't work at all), and similarly we need mouse release events on the
   // parent as windows don't get mouse releases.
-  gtk_widget_add_events(child_widget_parent_,
+  gtk_widget_add_events(window_contents_,
                         GDK_ENTER_NOTIFY_MASK |
                         GDK_LEAVE_NOTIFY_MASK |
                         GDK_BUTTON_PRESS_MASK |
                         GDK_BUTTON_RELEASE_MASK |
                         GDK_POINTER_MOTION_MASK |
                         GDK_KEY_PRESS_MASK |
                         GDK_KEY_RELEASE_MASK);
 
   root_view_->OnWidgetCreated();
 
   // TODO(port): if(has_own_focus_manager) block
 
   SetRootViewForWidget(widget_, root_view_.get());
 
   MessageLoopForUI::current()->AddObserver(this);
 
-  g_signal_connect_after(G_OBJECT(child_widget_parent_), "size_allocate",
+  // TODO(beng): make these take this rather than NULL.
+  g_signal_connect_after(G_OBJECT(window_contents_), "size_allocate",
                          G_CALLBACK(CallSizeAllocate), NULL);
-  g_signal_connect(G_OBJECT(child_widget_parent_), "expose_event",
+  g_signal_connect(G_OBJECT(window_contents_), "expose_event",
                    G_CALLBACK(CallPaint), NULL);
-  g_signal_connect(G_OBJECT(child_widget_parent_), "enter_notify_event",
+  g_signal_connect(G_OBJECT(window_contents_), "enter_notify_event",
                    G_CALLBACK(CallEnterNotify), NULL);
-  g_signal_connect(G_OBJECT(child_widget_parent_), "leave_notify_event",
+  g_signal_connect(G_OBJECT(window_contents_), "leave_notify_event",
                    G_CALLBACK(CallLeaveNotify), NULL);
-  g_signal_connect(G_OBJECT(child_widget_parent_), "motion_notify_event",
+  g_signal_connect(G_OBJECT(window_contents_), "motion_notify_event",
                    G_CALLBACK(CallMotionNotify), NULL);
-  g_signal_connect(G_OBJECT(child_widget_parent_), "button_press_event",
+  g_signal_connect(G_OBJECT(window_contents_), "button_press_event",
                    G_CALLBACK(CallButtonPress), NULL);
-  g_signal_connect(G_OBJECT(child_widget_parent_), "button_release_event",
+  g_signal_connect(G_OBJECT(window_contents_), "button_release_event",
                    G_CALLBACK(CallButtonRelease), NULL);
-  g_signal_connect(G_OBJECT(child_widget_parent_), "grab_broken_event",
+  g_signal_connect(G_OBJECT(window_contents_), "focus_out_event",
+                   G_CALLBACK(CallFocusOut), NULL);
+  g_signal_connect(G_OBJECT(window_contents_), "grab_broken_event",
                    G_CALLBACK(CallGrabBrokeEvent), NULL);
-  g_signal_connect(G_OBJECT(child_widget_parent_), "grab_notify",
+  g_signal_connect(G_OBJECT(window_contents_), "grab_notify",
                    G_CALLBACK(CallGrabNotify), NULL);
-  g_signal_connect(G_OBJECT(child_widget_parent_), "focus_out_event",
-                   G_CALLBACK(CallFocusOut), NULL);
-  g_signal_connect(G_OBJECT(child_widget_parent_), "key_press_event",
+  g_signal_connect(G_OBJECT(window_contents_), "key_press_event",
                    G_CALLBACK(CallKeyPress), NULL);
-  g_signal_connect(G_OBJECT(child_widget_parent_), "key_release_event",
+  g_signal_connect(G_OBJECT(window_contents_), "key_release_event",
                    G_CALLBACK(CallKeyRelease), NULL);
-  g_signal_connect(G_OBJECT(child_widget_parent_), "scroll_event",
+  g_signal_connect(G_OBJECT(window_contents_), "scroll_event",
                    G_CALLBACK(CallScroll), NULL);
-  g_signal_connect(G_OBJECT(child_widget_parent_), "visibility_notify_event",
+  g_signal_connect(G_OBJECT(window_contents_), "visibility_notify_event",
                    G_CALLBACK(CallVisibilityNotify), NULL);
 
   // In order to receive notification when the window is no longer the front
   // window, we need to install these on the widget.
   // NOTE: this doesn't work with focus follows mouse.
   g_signal_connect(G_OBJECT(widget_), "focus_in_event",
                    G_CALLBACK(CallFocusIn), NULL);
   g_signal_connect(G_OBJECT(widget_), "focus_out_event",
                    G_CALLBACK(CallFocusOut), NULL);
 
@@ skipping 11 matching lines @@
   // g_signal_connect(G_OBJECT(widget_), "drag_leave",
   //                  G_CALLBACK(drag_leave_event_cb), NULL);
   // g_signal_connect(G_OBJECT(widget_), "drag_drop",
   //                  G_CALLBACK(drag_drop_event_cb), NULL);
   // g_signal_connect(G_OBJECT(widget_), "drag_data_received",
   //                  G_CALLBACK(drag_data_received_event_cb), NULL);
 
   tooltip_manager_.reset(new TooltipManagerGtk(this));
 
   if (type_ == TYPE_CHILD) {
-    WidgetGtk* parent_widget = GetViewForNative(parent);
-    parent_widget->AddChild(widget_);
-    parent_widget->PositionChild(widget_, bounds.x(), bounds.y(),
-                                 bounds.width(), bounds.height());
+    if (parent) {
+      WidgetGtk* parent_widget = GetViewForNative(parent);
+      parent_widget->AddChild(widget_);
+      parent_widget->PositionChild(widget_, bounds.x(), bounds.y(),
+                                   bounds.width(), bounds.height());

[sky, 2009/06/16 16:01:45]

I think you need to persist the bounds some how, otherwise Show won't know what
bounds to show the widget at.

[Ben Goodger (Google), 2009/06/16 19:53:46]

It seems like the bounds setting will be done when the GtkWidget corresponding
to this WidgetGtk is attached to a NativeViewHost - the NativeViewHosts' bounds
will be applied.

+    }
   } else {
     if (bounds.width() > 0 && bounds.height() > 0)
       gtk_window_resize(GTK_WINDOW(widget_), bounds.width(), bounds.height());
     gtk_window_move(GTK_WINDOW(widget_), bounds.x(), bounds.y());
   }
 }
 
 bool WidgetGtk::MakeTransparent() {
   // Transparency can only be enabled for windows/popups and only if we haven't
   // realized the widget.
   DCHECK(!widget_ && type_ != TYPE_CHILD);
 
   if (!gdk_screen_is_composited(gdk_screen_get_default())) {
     // Transparency is only supported for compositing window managers.
     DLOG(WARNING) << "compsiting not supported";
     return false;
   }
 
   if (!gdk_screen_get_rgba_colormap(gdk_screen_get_default())) {
     // We need rgba to make the window transparent.
     return false;
   }
 
   transparent_ = true;
   return true;
 }
 
 void WidgetGtk::AddChild(GtkWidget* child) {
-  gtk_container_add(GTK_CONTAINER(child_widget_parent_), child);
+  gtk_container_add(GTK_CONTAINER(window_contents_), child);
 }
 
 void WidgetGtk::RemoveChild(GtkWidget* child) {
-  gtk_container_remove(GTK_CONTAINER(child_widget_parent_), child);
+  gtk_container_remove(GTK_CONTAINER(window_contents_), child);
+}
+
+void WidgetGtk::ReparentChild(GtkWidget* child) {
+  gtk_widget_reparent(child, window_contents_);
 }
 
 void WidgetGtk::PositionChild(GtkWidget* child, int x, int y, int w, int h) {
   GtkAllocation alloc = { x, y, w, h };
   // For some reason we need to do both of these to size a widget.
   gtk_widget_size_allocate(child, &alloc);
   gtk_widget_set_size_request(child, w, h);
-  gtk_fixed_move(GTK_FIXED(child_widget_parent_), child, x, y);
+  gtk_fixed_move(GTK_FIXED(window_contents_), child, x, y);
 }
 
 void WidgetGtk::SetContentsView(View* view) {
   DCHECK(view && widget_)
       << "Can't be called until after the HWND is created!";
   // The ContentsView must be set up _after_ the window is created so that its
   // Widget pointer is valid.
   root_view_->SetLayoutManager(new FillLayout);
   if (root_view_->GetChildViewCount() != 0)
     root_view_->RemoveAllChildViews(true);
@@ skipping 157 matching lines @@
 // WidgetGtk, MessageLoopForUI::Observer implementation:
 
 void WidgetGtk::DidProcessEvent(GdkEvent* event) {
   if (root_view_->NeedsPainting(true))
     PaintNow(root_view_->GetScheduledPaintRect());
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TODO(beng): organize into sections:
 
-void WidgetGtk::CreateGtkWidget() {
+void WidgetGtk::CreateGtkWidget(GtkWidget* parent) {
   if (type_ == TYPE_CHILD) {
-    child_widget_parent_ = widget_ = gtk_fixed_new();
+    window_contents_ = widget_ = gtk_fixed_new();
     gtk_fixed_set_has_window(GTK_FIXED(widget_), true);
+    if (!parent && !null_parent_) {
+      GtkWidget* popup = gtk_window_new(GTK_WINDOW_POPUP);
+      null_parent_ = gtk_fixed_new();
+      gtk_container_add(GTK_CONTAINER(popup), null_parent_);
+      gtk_widget_realize(null_parent_);
+    }
+    gtk_container_add(GTK_CONTAINER(parent ? parent : null_parent_), widget_);
     SetViewForNative(widget_, this);
   } else {
     widget_ = gtk_window_new(
         type_ == TYPE_WINDOW ? GTK_WINDOW_TOPLEVEL : GTK_WINDOW_POPUP);
     gtk_window_set_decorated(GTK_WINDOW(widget_), false);
     // We'll take care of positioning our window.
     gtk_window_set_position(GTK_WINDOW(widget_), GTK_WIN_POS_NONE);
     SetWindowForNative(widget_, static_cast<WindowGtk*>(this));
     SetViewForNative(widget_, this);
 
-    child_widget_parent_ = gtk_fixed_new();
-    gtk_fixed_set_has_window(GTK_FIXED(child_widget_parent_), true);
-    gtk_container_add(GTK_CONTAINER(widget_), child_widget_parent_);
-    gtk_widget_show(child_widget_parent_);
-    SetViewForNative(child_widget_parent_, this);
+    window_contents_ = gtk_fixed_new();
+    gtk_fixed_set_has_window(GTK_FIXED(window_contents_), true);
+    gtk_container_add(GTK_CONTAINER(widget_), window_contents_);
+    gtk_widget_show(window_contents_);
+    SetViewForNative(window_contents_, this);
 
     if (transparent_)
       ConfigureWidgetForTransparentBackground();
   }
-
   // The widget needs to be realized before handlers like size-allocate can
   // function properly.
   gtk_widget_realize(widget_);
 }
 
 void WidgetGtk::OnSizeAllocate(GtkWidget* widget, GtkAllocation* allocation) {
   root_view_->SetBounds(0, 0, allocation->width, allocation->height);
   root_view_->Layout();
   root_view_->SchedulePaint();
 }
@@ skipping 67 matching lines @@
   KeyEvent key_event(event);
   return root_view_->ProcessKeyEvent(key_event);
 }
 
 gboolean WidgetGtk::OnGrabBrokeEvent(GtkWidget* widget, GdkEvent* event) {
   HandleGrabBroke();
   return false;  // To let other widgets get the event.
 }
 
 void WidgetGtk::OnGrabNotify(GtkWidget* widget, gboolean was_grabbed) {
-  gtk_grab_remove(child_widget_parent_);
+  gtk_grab_remove(window_contents_);
   HandleGrabBroke();
 }
 
 void WidgetGtk::OnDestroy(GtkWidget* widget) {
-  widget_ = child_widget_parent_ = NULL;
+  widget_ = window_contents_ = NULL;
   root_view_->OnWidgetDestroyed();
   if (delete_on_destroy_)
     delete this;
 }
 
 // static
 WindowGtk* WidgetGtk::GetWindowForNative(GtkWidget* widget) {
   gpointer user_data = g_object_get_data(G_OBJECT(widget), "chrome-window");
   return static_cast<WindowGtk*>(user_data);
 }
@@ skipping 38 matching lines @@
     return true;
   }
 
   last_mouse_event_was_move_ = false;
   MouseEvent mouse_pressed(Event::ET_MOUSE_PRESSED, event->x, event->y,
                            GetFlagsForEventButton(*event));
   if (root_view_->OnMousePressed(mouse_pressed)) {
     is_mouse_down_ = true;
     if (!has_capture_) {
       has_capture_ = true;
-      gtk_grab_add(child_widget_parent_);
+      gtk_grab_add(window_contents_);
     }
     return true;
   }
 
   return false;
 }
 
 void WidgetGtk::ProcessMouseReleased(GdkEventButton* event) {
   last_mouse_event_was_move_ = false;
   MouseEvent mouse_up(Event::ET_MOUSE_RELEASED, event->x, event->y,
                       GetFlagsForEventButton(*event));
   // Release the capture first, that way we don't get confused if
   // OnMouseReleased blocks.
 
   if (has_capture_ && ReleaseCaptureOnMouseReleased()) {
     has_capture_ = false;
-    gtk_grab_remove(child_widget_parent_);
+    gtk_grab_remove(window_contents_);
   }
   is_mouse_down_ = false;
   root_view_->OnMouseReleased(mouse_up, false);
 }
 
 // static
 WidgetGtk* WidgetGtk::GetViewForNative(GtkWidget* widget) {
   gpointer user_data = g_object_get_data(G_OBJECT(widget), "chrome-views");
   return static_cast<WidgetGtk*>(user_data);
 }
@@ skipping 161 matching lines @@
   while (parent) {
     WidgetGtk* widget_gtk = GetViewForNative(parent);
     if (widget_gtk && widget_gtk->is_window_)
       return static_cast<WindowGtk*>(widget_gtk);
     parent = gtk_widget_get_parent(parent);
   }
   return NULL;
 }
 
 void WidgetGtk::ConfigureWidgetForTransparentBackground() {
-  DCHECK(widget_ && child_widget_parent_ &&
-         widget_ != child_widget_parent_);
+  DCHECK(widget_ && window_contents_ && widget_ != window_contents_);
 
   GdkColormap* rgba_colormap =
       gdk_screen_get_rgba_colormap(gdk_screen_get_default());
   if (!rgba_colormap) {
     transparent_ = false;
     return;
   }
   // To make the background transparent we need to install the RGBA colormap
   // on both the window and fixed. In addition we need to turn off double
   // buffering and make sure no decorations are drawn. The last bit is to make
   // sure the widget doesn't attempt to draw a pixmap in it's background.
   gtk_widget_set_colormap(widget_, rgba_colormap);
   gtk_widget_set_app_paintable(widget_, true);
   GTK_WIDGET_UNSET_FLAGS(widget_, GTK_DOUBLE_BUFFERED);
   gtk_widget_realize(widget_);
   gdk_window_set_decorations(widget_->window,
                              static_cast<GdkWMDecoration>(0));
   // Widget must be realized before setting pixmap.
   gdk_window_set_back_pixmap(widget_->window, NULL, FALSE);
 
-  gtk_widget_set_colormap(child_widget_parent_, rgba_colormap);
-  gtk_widget_set_app_paintable(child_widget_parent_, true);
-  GTK_WIDGET_UNSET_FLAGS(child_widget_parent_, GTK_DOUBLE_BUFFERED);
-  gtk_widget_realize(child_widget_parent_);
+  gtk_widget_set_colormap(window_contents_, rgba_colormap);
+  gtk_widget_set_app_paintable(window_contents_, true);
+  GTK_WIDGET_UNSET_FLAGS(window_contents_, GTK_DOUBLE_BUFFERED);
+  gtk_widget_realize(window_contents_);
   // Widget must be realized before setting pixmap.
-  gdk_window_set_back_pixmap(child_widget_parent_->window, NULL, FALSE);
+  gdk_window_set_back_pixmap(window_contents_->window, NULL, FALSE);
 }
 
 void WidgetGtk::HandleGrabBroke() {
   if (has_capture_) {
     if (is_mouse_down_)
       root_view_->ProcessMouseDragCanceled();
     is_mouse_down_ = false;
     has_capture_ = false;
   }
 }
 
 }  // namespace views