gecko-dev/widget/gtk/mozcontainer.cpp

563 строки
18 KiB
C++

/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* vim:expandtab:shiftwidth=4:tabstop=4:
*/
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "mozcontainer.h"
#include <gtk/gtk.h>
#ifdef MOZ_WAYLAND
#include <gdk/gdkx.h>
#include <gdk/gdkwayland.h>
#endif
#include <stdio.h>
#include <dlfcn.h>
#ifdef ACCESSIBILITY
#include <atk/atk.h>
#include "maiRedundantObjectFactory.h"
#endif
/* init methods */
static void moz_container_class_init (MozContainerClass *klass);
static void moz_container_init (MozContainer *container);
/* widget class methods */
static void moz_container_map (GtkWidget *widget);
static void moz_container_unmap (GtkWidget *widget);
static void moz_container_realize (GtkWidget *widget);
static void moz_container_size_allocate (GtkWidget *widget,
GtkAllocation *allocation);
/* container class methods */
static void moz_container_remove (GtkContainer *container,
GtkWidget *child_widget);
static void moz_container_forall (GtkContainer *container,
gboolean include_internals,
GtkCallback callback,
gpointer callback_data);
static void moz_container_add (GtkContainer *container,
GtkWidget *widget);
typedef struct _MozContainerChild MozContainerChild;
struct _MozContainerChild {
GtkWidget *widget;
gint x;
gint y;
};
static void moz_container_allocate_child (MozContainer *container,
MozContainerChild *child);
static MozContainerChild *
moz_container_get_child (MozContainer *container, GtkWidget *child);
/* public methods */
GType
moz_container_get_type(void)
{
static GType moz_container_type = 0;
if (!moz_container_type) {
static GTypeInfo moz_container_info = {
sizeof(MozContainerClass), /* class_size */
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) moz_container_class_init, /* class_init */
NULL, /* class_destroy */
NULL, /* class_data */
sizeof(MozContainer), /* instance_size */
0, /* n_preallocs */
(GInstanceInitFunc) moz_container_init, /* instance_init */
NULL, /* value_table */
};
moz_container_type = g_type_register_static (GTK_TYPE_CONTAINER,
"MozContainer",
&moz_container_info,
static_cast<GTypeFlags>(0));
#ifdef ACCESSIBILITY
/* Set a factory to return accessible object with ROLE_REDUNDANT for
* MozContainer, so that gail won't send focus notification for it */
atk_registry_set_factory_type(atk_get_default_registry(),
moz_container_type,
mai_redundant_object_factory_get_type());
#endif
}
return moz_container_type;
}
GtkWidget *
moz_container_new (void)
{
MozContainer *container;
container = static_cast<MozContainer*>(g_object_new (MOZ_CONTAINER_TYPE, nullptr));
return GTK_WIDGET(container);
}
void
moz_container_put (MozContainer *container, GtkWidget *child_widget,
gint x, gint y)
{
MozContainerChild *child;
child = g_new (MozContainerChild, 1);
child->widget = child_widget;
child->x = x;
child->y = y;
/* printf("moz_container_put %p %p %d %d\n", (void *)container,
(void *)child_widget, x, y); */
container->children = g_list_append (container->children, child);
/* we assume that the caller of this function will have already set
the parent GdkWindow because we can have many anonymous children. */
gtk_widget_set_parent(child_widget, GTK_WIDGET(container));
}
void
moz_container_move (MozContainer *container, GtkWidget *child_widget,
gint x, gint y, gint width, gint height)
{
MozContainerChild *child;
GtkAllocation new_allocation;
child = moz_container_get_child (container, child_widget);
child->x = x;
child->y = y;
new_allocation.x = x;
new_allocation.y = y;
new_allocation.width = width;
new_allocation.height = height;
/* printf("moz_container_move %p %p will allocate to %d %d %d %d\n",
(void *)container, (void *)child_widget,
new_allocation.x, new_allocation.y,
new_allocation.width, new_allocation.height); */
gtk_widget_size_allocate(child_widget, &new_allocation);
}
/* static methods */
void
moz_container_class_init (MozContainerClass *klass)
{
/*GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GtkObjectClass *object_class = GTK_OBJECT_CLASS (klass); */
GtkContainerClass *container_class = GTK_CONTAINER_CLASS (klass);
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
widget_class->map = moz_container_map;
widget_class->unmap = moz_container_unmap;
widget_class->realize = moz_container_realize;
widget_class->size_allocate = moz_container_size_allocate;
container_class->remove = moz_container_remove;
container_class->forall = moz_container_forall;
container_class->add = moz_container_add;
}
#if defined(MOZ_WAYLAND)
static void
registry_handle_global (void *data,
struct wl_registry *registry,
uint32_t name,
const char *interface,
uint32_t version)
{
MozContainer *container = MOZ_CONTAINER(data);
if(strcmp(interface, "wl_subcompositor") == 0) {
container->subcompositor =
static_cast<wl_subcompositor*>(wl_registry_bind(registry,
name,
&wl_subcompositor_interface,
1));
}
}
static void
registry_handle_global_remove (void *data,
struct wl_registry *registry,
uint32_t name)
{
}
static const struct wl_registry_listener registry_listener = {
registry_handle_global,
registry_handle_global_remove
};
#endif
void
moz_container_init (MozContainer *container)
{
gtk_widget_set_can_focus(GTK_WIDGET(container), TRUE);
gtk_container_set_resize_mode(GTK_CONTAINER(container), GTK_RESIZE_IMMEDIATE);
gtk_widget_set_redraw_on_allocate(GTK_WIDGET(container), FALSE);
#if defined(MOZ_WAYLAND)
{
GdkDisplay *gdk_display = gtk_widget_get_display(GTK_WIDGET(container));
if (GDK_IS_WAYLAND_DISPLAY (gdk_display)) {
// Available as of GTK 3.8+
static auto sGdkWaylandDisplayGetWlDisplay =
(wl_display *(*)(GdkDisplay *))
dlsym(RTLD_DEFAULT, "gdk_wayland_display_get_wl_display");
wl_display* display = sGdkWaylandDisplayGetWlDisplay(gdk_display);
wl_registry* registry = wl_display_get_registry(display);
wl_registry_add_listener(registry, &registry_listener, container);
wl_display_dispatch(display);
wl_display_roundtrip(display);
}
}
#endif
}
#if defined(MOZ_WAYLAND)
/* We want to draw to GdkWindow owned by mContainer from Compositor thread but
* Gtk+ can be used in main thread only. So we create wayland wl_surface
* and attach it as an overlay to GdkWindow.
*
* see gtk_clutter_embed_ensure_subsurface() at gtk-clutter-embed.c
* for reference.
*/
static gboolean
moz_container_map_surface(MozContainer *container)
{
// Available as of GTK 3.8+
static auto sGdkWaylandDisplayGetWlCompositor =
(wl_compositor *(*)(GdkDisplay *))
dlsym(RTLD_DEFAULT, "gdk_wayland_display_get_wl_compositor");
static auto sGdkWaylandWindowGetWlSurface =
(wl_surface *(*)(GdkWindow *))
dlsym(RTLD_DEFAULT, "gdk_wayland_window_get_wl_surface");
GdkDisplay *display = gtk_widget_get_display(GTK_WIDGET(container));
if (GDK_IS_X11_DISPLAY(display))
return false;
if (container->subsurface && container->surface)
return true;
if (!container->surface) {
struct wl_compositor *compositor;
compositor = sGdkWaylandDisplayGetWlCompositor(display);
container->surface = wl_compositor_create_surface(compositor);
}
if (!container->subsurface) {
GdkWindow* window = gtk_widget_get_window(GTK_WIDGET(container));
wl_surface* gtk_surface = sGdkWaylandWindowGetWlSurface(window);
if (!gtk_surface) {
// We requested the underlying wl_surface too early when container
// is not realized yet. We'll try again before first rendering
// to mContainer.
return false;
}
container->subsurface =
wl_subcompositor_get_subsurface (container->subcompositor,
container->surface,
gtk_surface);
gint x, y;
gdk_window_get_position(window, &x, &y);
wl_subsurface_set_position(container->subsurface, x, y);
wl_subsurface_set_desync(container->subsurface);
// Route input to parent wl_surface owned by Gtk+ so we get input
// events from Gtk+.
GdkDisplay* display = gtk_widget_get_display(GTK_WIDGET (container));
wl_compositor* compositor = sGdkWaylandDisplayGetWlCompositor(display);
wl_region* region = wl_compositor_create_region(compositor);
wl_surface_set_input_region(container->surface, region);
wl_region_destroy(region);
}
return true;
}
static void
moz_container_unmap_surface(MozContainer *container)
{
g_clear_pointer(&container->subsurface, wl_subsurface_destroy);
g_clear_pointer(&container->surface, wl_surface_destroy);
}
#endif
void
moz_container_map (GtkWidget *widget)
{
MozContainer *container;
GList *tmp_list;
GtkWidget *tmp_child;
g_return_if_fail (IS_MOZ_CONTAINER(widget));
container = MOZ_CONTAINER (widget);
gtk_widget_set_mapped(widget, TRUE);
tmp_list = container->children;
while (tmp_list) {
tmp_child = ((MozContainerChild *)tmp_list->data)->widget;
if (gtk_widget_get_visible(tmp_child)) {
if (!gtk_widget_get_mapped(tmp_child))
gtk_widget_map(tmp_child);
}
tmp_list = tmp_list->next;
}
if (gtk_widget_get_has_window (widget)) {
gdk_window_show (gtk_widget_get_window(widget));
#if defined(MOZ_WAYLAND)
moz_container_map_surface(MOZ_CONTAINER(widget));
#endif
}
}
void
moz_container_unmap (GtkWidget *widget)
{
g_return_if_fail (IS_MOZ_CONTAINER (widget));
gtk_widget_set_mapped(widget, FALSE);
if (gtk_widget_get_has_window (widget)) {
gdk_window_hide (gtk_widget_get_window(widget));
#if defined(MOZ_WAYLAND)
moz_container_unmap_surface(MOZ_CONTAINER(widget));
#endif
}
}
void
moz_container_realize (GtkWidget *widget)
{
GdkWindow *parent = gtk_widget_get_parent_window (widget);
GdkWindow *window;
gtk_widget_set_realized(widget, TRUE);
if (gtk_widget_get_has_window (widget)) {
GdkWindowAttr attributes;
gint attributes_mask = GDK_WA_VISUAL | GDK_WA_X | GDK_WA_Y;
GtkAllocation allocation;
gtk_widget_get_allocation (widget, &allocation);
attributes.event_mask = gtk_widget_get_events (widget);
attributes.x = allocation.x;
attributes.y = allocation.y;
attributes.width = allocation.width;
attributes.height = allocation.height;
attributes.wclass = GDK_INPUT_OUTPUT;
attributes.visual = gtk_widget_get_visual (widget);
attributes.window_type = GDK_WINDOW_CHILD;
window = gdk_window_new (parent, &attributes, attributes_mask);
gdk_window_set_user_data (window, widget);
} else {
window = parent;
g_object_ref (window);
}
gtk_widget_set_window (widget, window);
}
void
moz_container_size_allocate (GtkWidget *widget,
GtkAllocation *allocation)
{
MozContainer *container;
GList *tmp_list;
GtkAllocation tmp_allocation;
g_return_if_fail (IS_MOZ_CONTAINER (widget));
/* printf("moz_container_size_allocate %p %d %d %d %d\n",
(void *)widget,
allocation->x,
allocation->y,
allocation->width,
allocation->height); */
/* short circuit if you can */
container = MOZ_CONTAINER (widget);
gtk_widget_get_allocation(widget, &tmp_allocation);
if (!container->children &&
tmp_allocation.x == allocation->x &&
tmp_allocation.y == allocation->y &&
tmp_allocation.width == allocation->width &&
tmp_allocation.height == allocation->height) {
return;
}
gtk_widget_set_allocation(widget, allocation);
tmp_list = container->children;
while (tmp_list) {
MozContainerChild *child = static_cast<MozContainerChild*>(tmp_list->data);
moz_container_allocate_child (container, child);
tmp_list = tmp_list->next;
}
if (gtk_widget_get_has_window (widget) &&
gtk_widget_get_realized (widget)) {
gdk_window_move_resize(gtk_widget_get_window(widget),
allocation->x,
allocation->y,
allocation->width,
allocation->height);
}
#if defined(MOZ_WAYLAND)
// We need to position our subsurface according to GdkWindow
// when offset changes (GdkWindow is maximized for instance).
// see gtk-clutter-embed.c for reference.
if (container->subsurface) {
gint x, y;
gdk_window_get_position(gtk_widget_get_window(widget), &x, &y);
wl_subsurface_set_position(container->subsurface, x, y);
}
#endif
}
void
moz_container_remove (GtkContainer *container, GtkWidget *child_widget)
{
MozContainerChild *child;
MozContainer *moz_container;
GdkWindow* parent_window;
g_return_if_fail (IS_MOZ_CONTAINER(container));
g_return_if_fail (GTK_IS_WIDGET(child_widget));
moz_container = MOZ_CONTAINER(container);
child = moz_container_get_child (moz_container, child_widget);
g_return_if_fail (child);
/* gtk_widget_unparent will remove the parent window (as well as the
* parent widget), but, in Mozilla's window hierarchy, the parent window
* may need to be kept because it may be part of a GdkWindow sub-hierarchy
* that is being moved to another MozContainer.
*
* (In a conventional GtkWidget hierarchy, GdkWindows being reparented
* would have their own GtkWidget and that widget would be the one being
* reparented. In Mozilla's hierarchy, the parent_window needs to be
* retained so that the GdkWindow sub-hierarchy is maintained.)
*/
parent_window = gtk_widget_get_parent_window(child_widget);
if (parent_window)
g_object_ref(parent_window);
gtk_widget_unparent(child_widget);
if (parent_window) {
/* The child_widget will always still exist because g_signal_emit,
* which invokes this function, holds a reference.
*
* If parent_window is the container's root window then it will not be
* the parent_window if the child_widget is placed in another
* container.
*/
if (parent_window != gtk_widget_get_window(GTK_WIDGET(container)))
gtk_widget_set_parent_window(child_widget, parent_window);
g_object_unref(parent_window);
}
moz_container->children = g_list_remove(moz_container->children, child);
g_free(child);
}
void
moz_container_forall (GtkContainer *container, gboolean include_internals,
GtkCallback callback, gpointer callback_data)
{
MozContainer *moz_container;
GList *tmp_list;
g_return_if_fail (IS_MOZ_CONTAINER(container));
g_return_if_fail (callback != NULL);
moz_container = MOZ_CONTAINER(container);
tmp_list = moz_container->children;
while (tmp_list) {
MozContainerChild *child;
child = static_cast<MozContainerChild*>(tmp_list->data);
tmp_list = tmp_list->next;
(* callback) (child->widget, callback_data);
}
}
static void
moz_container_allocate_child (MozContainer *container,
MozContainerChild *child)
{
GtkAllocation allocation;
gtk_widget_get_allocation (child->widget, &allocation);
allocation.x = child->x;
allocation.y = child->y;
gtk_widget_size_allocate (child->widget, &allocation);
}
MozContainerChild *
moz_container_get_child (MozContainer *container, GtkWidget *child_widget)
{
GList *tmp_list;
tmp_list = container->children;
while (tmp_list) {
MozContainerChild *child;
child = static_cast<MozContainerChild*>(tmp_list->data);
tmp_list = tmp_list->next;
if (child->widget == child_widget)
return child;
}
return NULL;
}
static void
moz_container_add(GtkContainer *container, GtkWidget *widget)
{
moz_container_put(MOZ_CONTAINER(container), widget, 0, 0);
}
#ifdef MOZ_WAYLAND
struct wl_surface*
moz_container_get_wl_surface(MozContainer *container)
{
if (!container->subsurface || !container->surface) {
GdkWindow* window = gtk_widget_get_window(GTK_WIDGET(container));
if (!gdk_window_is_visible(window))
return nullptr;
moz_container_map_surface(container);
}
return container->surface;
}
#endif