Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 402 insertions, 0 deletions

diff --git a/widget/gtk/MozContainer.cpp b/widget/gtk/MozContainer.cpp
new file mode 100644
index 0000000000..95d32b57b4
--- /dev/null
+++ b/widget/gtk/MozContainer.cpp
@@ -0,0 +1,402 @@
+/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:expandtab:shiftwidth=2:tabstop=2:
+ */
+/* 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 <glib.h>
+#include <gtk/gtk.h>
+#include <stdio.h>
+#include "mozilla/WidgetUtilsGtk.h"
+#include "nsWindow.h"
+
+#ifdef MOZ_LOGGING
+#  include "mozilla/Logging.h"
+#  include "nsTArray.h"
+#  include "Units.h"
+extern mozilla::LazyLogModule gWidgetLog;
+#  define LOGCONTAINER(args) MOZ_LOG(gWidgetLog, mozilla::LogLevel::Debug, args)
+#else
+#  define LOGCONTAINER(args)
+#endif /* MOZ_LOGGING */
+
+/* init methods */
+void moz_container_class_init(MozContainerClass* klass);
+static void moz_container_init(MozContainer* container);
+
+/* widget class methods */
+static void moz_container_map(GtkWidget* widget);
+void moz_container_unmap(GtkWidget* widget);
+static void moz_container_size_allocate(GtkWidget* widget,
+                                        GtkAllocation* allocation);
+static void moz_container_realize(GtkWidget* widget);
+static void moz_container_unrealize(GtkWidget* widget);
+
+/* 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));
+  }
+
+  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->data.children = g_list_append(container->data.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));
+}
+
+static void moz_container_destroy(GtkWidget* widget) {
+  auto* container = MOZ_CONTAINER(widget);
+  if (container->destroyed) {
+    return;  // The destroy signal may run multiple times.
+  }
+  LOGCONTAINER(("moz_container_destroy() [%p]\n",
+                (void*)moz_container_get_nsWindow(MOZ_CONTAINER(widget))));
+  container->destroyed = TRUE;
+  container->data.~Data();
+}
+
+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->realize = moz_container_realize;
+  widget_class->unrealize = moz_container_unrealize;
+  widget_class->destroy = moz_container_destroy;
+
+#ifdef MOZ_WAYLAND
+  if (mozilla::widget::GdkIsWaylandDisplay()) {
+    widget_class->map = moz_container_wayland_map;
+    widget_class->size_allocate = moz_container_wayland_size_allocate;
+    widget_class->map_event = moz_container_wayland_map_event;
+    widget_class->unmap = moz_container_wayland_unmap;
+  } else {
+#endif
+    widget_class->map = moz_container_map;
+    widget_class->size_allocate = moz_container_size_allocate;
+    widget_class->unmap = moz_container_unmap;
+#ifdef MOZ_WAYLAND
+  }
+#endif
+
+  container_class->remove = moz_container_remove;
+  container_class->forall = moz_container_forall;
+  container_class->add = moz_container_add;
+}
+
+void moz_container_init(MozContainer* container) {
+  container->destroyed = FALSE;
+  new (&container->data) MozContainer::Data();
+  gtk_widget_set_can_focus(GTK_WIDGET(container), TRUE);
+  gtk_widget_set_redraw_on_allocate(GTK_WIDGET(container), FALSE);
+  LOGCONTAINER(("%s [%p]\n", __FUNCTION__,
+                (void*)moz_container_get_nsWindow(container)));
+}
+
+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);
+
+  LOGCONTAINER(("moz_container_map() [%p]",
+                (void*)moz_container_get_nsWindow(container)));
+
+  gtk_widget_set_mapped(widget, TRUE);
+
+  tmp_list = container->data.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));
+  }
+}
+
+void moz_container_unmap(GtkWidget* widget) {
+  g_return_if_fail(IS_MOZ_CONTAINER(widget));
+
+  LOGCONTAINER(("moz_container_unmap() [%p]",
+                (void*)moz_container_get_nsWindow(MOZ_CONTAINER(widget))));
+
+  // Disable rendering to MozContainer before we unmap it.
+  nsWindow* window = moz_container_get_nsWindow(MOZ_CONTAINER(widget));
+  window->DisableRendering();
+
+  gtk_widget_set_mapped(widget, FALSE);
+
+  if (gtk_widget_get_has_window(widget)) {
+    gdk_window_hide(gtk_widget_get_window(widget));
+  }
+}
+
+void moz_container_realize(GtkWidget* widget) {
+  GdkWindow* parent = gtk_widget_get_parent_window(widget);
+  GdkWindow* window;
+
+  gtk_widget_set_realized(widget, TRUE);
+
+  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.window_type = GDK_WINDOW_CHILD;
+  MozContainer* container = MOZ_CONTAINER(widget);
+  attributes.visual =
+      container->data.force_default_visual
+          ? gdk_screen_get_system_visual(gtk_widget_get_screen(widget))
+          : gtk_widget_get_visual(widget);
+
+  window = gdk_window_new(parent, &attributes, attributes_mask);
+
+  LOGCONTAINER(("moz_container_realize() [%p] GdkWindow %p\n",
+                (void*)moz_container_get_nsWindow(container), (void*)window));
+
+  gtk_widget_register_window(widget, window);
+  gtk_widget_set_window(widget, window);
+}
+
+void moz_container_unrealize(GtkWidget* widget) {
+  GdkWindow* window = gtk_widget_get_window(widget);
+  LOGCONTAINER(("moz_container_unrealize() [%p] GdkWindow %p\n",
+                (void*)moz_container_get_nsWindow(MOZ_CONTAINER(widget)),
+                (void*)window));
+
+  if (gtk_widget_get_mapped(widget)) {
+    gtk_widget_unmap(widget);
+  }
+
+  gtk_widget_unregister_window(widget, window);
+  gtk_widget_set_window(widget, nullptr);
+  gdk_window_destroy(window);
+  gtk_widget_set_realized(widget, false);
+}
+
+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));
+
+  LOGCONTAINER(("moz_container_size_allocate [%p] %d,%d -> %d x %d\n",
+                (void*)moz_container_get_nsWindow(MOZ_CONTAINER(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->data.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->data.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);
+  }
+}
+
+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->data.children =
+      g_list_remove(moz_container->data.children, child);
+  g_free(child);
+}
+
+void moz_container_forall(GtkContainer* container, gboolean include_internals,
+                          GtkCallback callback, gpointer callback_data) {
+  g_return_if_fail(IS_MOZ_CONTAINER(container));
+  g_return_if_fail(callback);
+
+  MozContainer* moz_container = MOZ_CONTAINER(container);
+
+  GList* tmp_list = moz_container->data.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 = container->data.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 nullptr;
+}
+
+static void moz_container_add(GtkContainer* container, GtkWidget* widget) {
+  moz_container_put(MOZ_CONTAINER(container), widget, 0, 0);
+}
+
+void moz_container_force_default_visual(MozContainer* container) {
+  container->data.force_default_visual = true;
+}
+
+nsWindow* moz_container_get_nsWindow(MozContainer* container) {
+  gpointer user_data = g_object_get_data(G_OBJECT(container), "nsWindow");
+  return static_cast<nsWindow*>(user_data);
+}
+
+#undef LOGCONTAINER