gecko-dev/widget/gtk/mozcontainer.cpp

/* -*- 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>
#include <gdk/gdkx.h>
#ifdef MOZ_WAYLAND
#include "nsWaylandDisplay.h"
#include <wayland-egl.h>
#endif
#include <stdio.h>
#include <dlfcn.h>

#ifdef ACCESSIBILITY
#include <atk/atk.h>
#include "maiRedundantObjectFactory.h"
#endif

#ifdef MOZ_WAYLAND
using namespace mozilla;
using namespace mozilla::widget;
#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;
}

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)
    container->surface = nullptr;
    container->subsurface = nullptr;
    container->eglwindow = nullptr;
    container->parent_surface_committed = false;
    container->needs_clear = true;
#endif
}

#if defined(MOZ_WAYLAND)
static void
moz_container_commited_handler(GdkFrameClock *clock, MozContainer *container)
{
    container->parent_surface_committed = true;
    g_signal_handler_disconnect(clock,
                                container->parent_surface_committed_handler);
    container->parent_surface_committed_handler = 0;
}

/* 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");
    static auto sGdkWindowGetFrameClock =
        (GdkFrameClock *(*)(GdkWindow *))
        dlsym(RTLD_DEFAULT, "gdk_window_get_frame_clock");

    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->parent_surface_committed) {
        if (!container->parent_surface_committed_handler) {
            GdkWindow* window = gtk_widget_get_window(GTK_WIDGET(container));
            GdkFrameClock *clock = sGdkWindowGetFrameClock(window);
            container->parent_surface_committed_handler =
                g_signal_connect_after(clock, "after-paint",
                                       G_CALLBACK(moz_container_commited_handler),
                                       container);
        }
        return false;
    }

    if (!container->surface) {
        // TODO - use nsWaylandDisplay::compositor for compositor thread.
        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;
        }
        GdkDisplay* display = gtk_widget_get_display(GTK_WIDGET(container));
        nsWaylandDisplay* waylandDisplay = WaylandDisplayGet(display);
        wl_subcompositor* subcompositor = waylandDisplay->GetSubcompositor();
         container->subsurface =
            wl_subcompositor_get_subsurface(subcompositor,
                                            container->surface,
                                            gtk_surface);
        WaylandDisplayRelease(waylandDisplay);

        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+.
        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);

        container->needs_clear = true;
    }
    return true;
}

static void
moz_container_unmap_surface(MozContainer *container)
{
    g_clear_pointer(&container->eglwindow, wl_egl_window_destroy);
    g_clear_pointer(&container->subsurface, wl_subsurface_destroy);
    g_clear_pointer(&container->surface, wl_surface_destroy);

    if (container->parent_surface_committed_handler) {
        static auto sGdkWindowGetFrameClock =
            (GdkFrameClock *(*)(GdkWindow *))
            dlsym(RTLD_DEFAULT, "gdk_window_get_frame_clock");
        GdkWindow* window = gtk_widget_get_window(GTK_WIDGET(container));
        GdkFrameClock *clock = sGdkWindowGetFrameClock(window);

        g_signal_handler_disconnect(clock,
                                    container->parent_surface_committed_handler);
        container->parent_surface_committed_handler = 0;
    }
    container->parent_surface_committed = false;
}
#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);
    }
    if (container->eglwindow) {
        wl_egl_window_resize(container->eglwindow,
                             allocation->width, allocation->height,
                             0, 0);
    }
#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);
        // Set the scale factor for the buffer right after we create it.
        if (container->surface) {
            static auto sGdkWindowGetScaleFactorPtr = (gint (*)(GdkWindow*))
            dlsym(RTLD_DEFAULT, "gdk_window_get_scale_factor");
            if (sGdkWindowGetScaleFactorPtr && window) {
              gint scaleFactor = (*sGdkWindowGetScaleFactorPtr)(window);
              wl_surface_set_buffer_scale(container->surface, scaleFactor);
            }
        }
    }

    return container->surface;
}

struct wl_egl_window *
moz_container_get_wl_egl_window(MozContainer *container)
{
    if (!container->eglwindow) {
        struct wl_surface *wlsurf = moz_container_get_wl_surface(container);
        if (!wlsurf)
            return nullptr;

      GdkWindow *window = gtk_widget_get_window(GTK_WIDGET(container));
      container->eglwindow
            = wl_egl_window_create(wlsurf,
                                   gdk_window_get_width(window),
                                   gdk_window_get_height(window));
    }
    return container->eglwindow;
}

gboolean
moz_container_has_wl_egl_window(MozContainer *container)
{
    return container->eglwindow ? true : false;
}

gboolean
moz_container_needs_clear(MozContainer *container)
{
    gboolean state = container->needs_clear;
    container->needs_clear = false;
    return state;
}
#endif