Import Upstream version 43.0upstream/latest

1 files changed, 474 insertions, 0 deletions

diff --git a/src/gui/gtd-max-size-layout.c b/src/gui/gtd-max-size-layout.c
new file mode 100644
index 0000000..348b2ed
--- /dev/null
+++ b/src/gui/gtd-max-size-layout.c
@@ -0,0 +1,474 @@
+/* gtd-max-size-layout.c
+ *
+ * Copyright 2020 Georges Basile Stavracas Neto <georges.stavracas@gmail.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+#include "gtd-max-size-layout.h"
+#include "gtd-widget.h"
+
+struct _GtdMaxSizeLayout
+{
+  GtkLayoutManager    parent;
+
+  gint                max_height;
+  gint                max_width;
+  gint                max_width_chars;
+  gint                width_chars;
+};
+
+G_DEFINE_TYPE (GtdMaxSizeLayout, gtd_max_size_layout, GTK_TYPE_LAYOUT_MANAGER)
+
+enum
+{
+  PROP_0,
+  PROP_MAX_HEIGHT,
+  PROP_MAX_WIDTH_CHARS,
+  PROP_MAX_WIDTH,
+  PROP_WIDTH_CHARS,
+  N_PROPS
+};
+
+static GParamSpec *properties [N_PROPS];
+
+
+/*
+ * GtkLayoutManager overrides
+ */
+
+static void
+gtd_max_size_layout_measure (GtkLayoutManager *layout_manager,
+                             GtkWidget        *widget,
+                             GtkOrientation    orientation,
+                             gint              for_size,
+                             gint             *minimum,
+                             gint             *natural,
+                             gint             *minimum_baseline,
+                             gint             *natural_baseline)
+{
+  GtdMaxSizeLayout *self = (GtdMaxSizeLayout *)layout_manager;
+  GtkWidget *child;
+
+  for (child = gtk_widget_get_first_child (widget);
+       child != NULL;
+       child = gtk_widget_get_next_sibling (child))
+    {
+      gint child_min_baseline = -1;
+      gint child_nat_baseline = -1;
+      gint child_min = 0;
+      gint child_nat = 0;
+
+      if (!gtk_widget_should_layout (child))
+        continue;
+
+      gtk_widget_measure (child, orientation, for_size,
+                          &child_min, &child_nat,
+                          &child_min_baseline, &child_nat_baseline);
+
+      *minimum = MAX (*minimum, child_min);
+      *natural = MAX (*natural, child_nat);
+
+      if (child_min_baseline > -1)
+        *minimum_baseline = MAX (*minimum_baseline, child_min_baseline);
+      if (child_nat_baseline > -1)
+        *natural_baseline = MAX (*natural_baseline, child_nat_baseline);
+    }
+
+  if (orientation == GTK_ORIENTATION_HORIZONTAL)
+    {
+      PangoFontMetrics *metrics;
+      PangoContext *context;
+      gint char_width;
+
+      context = gtk_widget_get_pango_context (widget);
+      metrics = pango_context_get_metrics (context,
+                                           pango_context_get_font_description (context),
+                                           pango_context_get_language (context));
+
+      char_width = MAX (pango_font_metrics_get_approximate_char_width (metrics),
+                        pango_font_metrics_get_approximate_digit_width (metrics));
+
+      if (self->width_chars > 0)
+        {
+          gint width_chars;
+
+          width_chars = char_width * self->width_chars / PANGO_SCALE;
+          *minimum = MAX (*minimum, width_chars);
+          *natural = MAX (*natural, width_chars);
+        }
+
+      if (self->max_width_chars > 0)
+        {
+          gint max_width_chars;
+
+          max_width_chars = char_width * self->max_width_chars / PANGO_SCALE;
+          *minimum = MIN (*minimum, max_width_chars);
+          *natural = MAX (*natural, max_width_chars);
+        }
+
+      if (self->max_width > 0)
+        {
+          *minimum = MIN (*minimum, self->max_width);
+          *natural = MAX (*natural, self->max_width);
+        }
+
+      pango_font_metrics_unref (metrics);
+    }
+  else if (self->max_height > 0)
+    {
+      *minimum = MIN (*minimum, self->max_height);
+      *natural = MAX (*natural, self->max_height);
+    }
+}
+
+static void
+gtd_max_size_layout_allocate (GtkLayoutManager *layout_manager,
+                              GtkWidget        *widget,
+                              gint              width,
+                              gint              height,
+                              gint              baseline)
+{
+  GtkWidget *child;
+
+  for (child = gtk_widget_get_first_child (widget);
+       child != NULL;
+       child = gtk_widget_get_next_sibling (child))
+    {
+      if (child && gtk_widget_should_layout (child))
+        {
+          GskTransform *transform = NULL;
+
+          if (GTD_IS_WIDGET (child))
+            transform = gtd_widget_apply_transform (GTD_WIDGET (child), NULL);
+
+          gtk_widget_allocate (child, width, height, baseline, transform);
+        }
+    }
+}
+
+
+/*
+ * GObject overrides
+ */
+
+static void
+gtd_max_size_layout_get_property (GObject    *object,
+                                  guint       prop_id,
+                                  GValue     *value,
+                                  GParamSpec *pspec)
+{
+  GtdMaxSizeLayout *self = GTD_MAX_SIZE_LAYOUT (object);
+
+  switch (prop_id)
+    {
+    case PROP_MAX_HEIGHT:
+      g_value_set_int (value, self->max_height);
+      break;
+
+    case PROP_MAX_WIDTH:
+      g_value_set_int (value, self->max_width);
+      break;
+
+    case PROP_MAX_WIDTH_CHARS:
+      g_value_set_int (value, self->max_width_chars);
+      break;
+
+    case PROP_WIDTH_CHARS:
+      g_value_set_int (value, self->width_chars);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+    }
+}
+
+static void
+gtd_max_size_layout_set_property (GObject      *object,
+                                  guint         prop_id,
+                                  const GValue *value,
+                                  GParamSpec   *pspec)
+{
+  GtdMaxSizeLayout *self = GTD_MAX_SIZE_LAYOUT (object);
+
+  switch (prop_id)
+    {
+    case PROP_MAX_HEIGHT:
+      gtd_max_size_layout_set_max_height (self, g_value_get_int (value));
+      break;
+
+    case PROP_MAX_WIDTH:
+      gtd_max_size_layout_set_max_width (self, g_value_get_int (value));
+      break;
+
+    case PROP_MAX_WIDTH_CHARS:
+      gtd_max_size_layout_set_max_width_chars (self, g_value_get_int (value));
+      break;
+
+    case PROP_WIDTH_CHARS:
+      gtd_max_size_layout_set_width_chars (self, g_value_get_int (value));
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+    }
+}
+
+static void
+gtd_max_size_layout_class_init (GtdMaxSizeLayoutClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  GtkLayoutManagerClass *layout_manager_class = GTK_LAYOUT_MANAGER_CLASS (klass);
+
+  layout_manager_class->measure = gtd_max_size_layout_measure;
+  layout_manager_class->allocate = gtd_max_size_layout_allocate;
+
+  object_class->get_property = gtd_max_size_layout_get_property;
+  object_class->set_property = gtd_max_size_layout_set_property;
+
+  /**
+   * GtdMaxSizeLayout:max-height:
+   *
+   * Sets the maximum height of the #GtkWidget.
+   */
+  properties[PROP_MAX_HEIGHT] = g_param_spec_int ("max-height",
+                                                  "Max Height",
+                                                  "Max Height",
+                                                  -1,
+                                                  G_MAXINT,
+                                                  -1,
+                                                  G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
+  /**
+   * GtdMaxSizeLayout:max-width:
+   *
+   * Sets the maximum width of the #GtkWidget.
+   */
+  properties[PROP_MAX_WIDTH] = g_param_spec_int ("max-width",
+                                                 "Max Width",
+                                                 "Max Width",
+                                                 -1,
+                                                 G_MAXINT,
+                                                 -1,
+                                                 G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
+  /**
+   * GtdMaxSizeLayout:max-width-chars:
+   *
+   * Sets the maximum size of the #GtkWidget in characters.
+   */
+  properties[PROP_MAX_WIDTH_CHARS] = g_param_spec_int ("max-width-chars",
+                                                       "Max Width Chars",
+                                                       "Max Width Chars",
+                                                       -1,
+                                                       G_MAXINT,
+                                                       -1,
+                                                       G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
+  /**
+   * GtdMaxSizeLayout:width-chars:
+   *
+   * Sets the size of the #GtkWidget in characters.
+   */
+  properties[PROP_WIDTH_CHARS] = g_param_spec_int ("width-chars",
+                                                   "Width Chars",
+                                                   "Width Chars",
+                                                   -1,
+                                                   G_MAXINT,
+                                                   -1,
+                                                   G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
+  g_object_class_install_properties (object_class, N_PROPS, properties);
+}
+
+static void
+gtd_max_size_layout_init (GtdMaxSizeLayout *self)
+{
+  self->max_height = -1;
+  self->max_width = -1;
+  self->max_width_chars = -1;
+  self->width_chars = -1;
+}
+
+/**
+ * gtd_max_size_layout_new:
+ *
+ * Creates a new #GtdMaxSizeLayout.
+ *
+ * Returns: (transfer full): a #GtdMaxSizeLayout
+ */
+GtkLayoutManager*
+gtd_max_size_layout_new (void)
+{
+  return g_object_new (GTD_TYPE_MAX_SIZE_LAYOUT, NULL);
+}
+
+/**
+ * gtd_max_size_layout_get_max_height:
+ *
+ * Retrieves the maximum height of @self.
+ *
+ * Returns: maximum height
+ */
+gint
+gtd_max_size_layout_get_max_height (GtdMaxSizeLayout *self)
+{
+  g_return_val_if_fail (GTD_IS_MAX_SIZE_LAYOUT (self), -1);
+
+  return self->max_height;
+}
+
+/**
+ * gtd_max_size_layout_set_max_height:
+ * @self: a #GtdMaxSizeLayout
+ * @max_height: maximum height of the widget @self is attached to
+ *
+ * Sets the maximum height @self has.
+ */
+void
+gtd_max_size_layout_set_max_height (GtdMaxSizeLayout *self,
+                                    gint              max_height)
+{
+  g_return_if_fail (GTD_IS_MAX_SIZE_LAYOUT (self));
+  g_return_if_fail (max_height >= -1);
+
+  if (self->max_height == max_height)
+    return;
+
+  self->max_height = max_height;
+  gtk_layout_manager_layout_changed (GTK_LAYOUT_MANAGER (self));
+
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_MAX_HEIGHT]);
+}
+
+/**
+ * gtd_max_size_layout_get_max_width:
+ *
+ * Retrieves the maximum width of @self.
+ *
+ * Returns: maximum width
+ */
+gint
+gtd_max_size_layout_get_max_width (GtdMaxSizeLayout *self)
+{
+
+  g_return_val_if_fail (GTD_IS_MAX_SIZE_LAYOUT (self), -1);
+
+  return self->max_width;
+}
+
+/**
+ * gtd_max_size_layout_set_max_width:
+ * @self: a #GtdMaxSizeLayout
+ * @max_width: maximum width of the widget @self is attached to
+ *
+ * Sets the maximum width @self has.
+ */
+void
+gtd_max_size_layout_set_max_width (GtdMaxSizeLayout *self,
+                                   gint              max_width)
+{
+  g_return_if_fail (GTD_IS_MAX_SIZE_LAYOUT (self));
+  g_return_if_fail (max_width >= -1);
+
+  if (self->max_width == max_width)
+    return;
+
+  self->max_width = max_width;
+  gtk_layout_manager_layout_changed (GTK_LAYOUT_MANAGER (self));
+
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_MAX_WIDTH]);
+}
+
+/**
+ * gtd_max_size_layout_get_max_width_chars:
+ *
+ * Retrieves the maximum width in characters of @self.
+ *
+ * Returns: maximum width in characters
+ */
+gint
+gtd_max_size_layout_get_max_width_chars (GtdMaxSizeLayout *self)
+{
+  g_return_val_if_fail (GTD_IS_MAX_SIZE_LAYOUT (self), -1);
+
+  return self->max_width_chars;
+}
+
+/**
+ * gtd_max_size_layout_set_max_width_chars:
+ * @self: a #GtdMaxSizeLayout
+ * @max_width_chars: maximum width of the widget @self is attached to, in character length
+ *
+ * Sets the maximum width @self has, in characters length. It is a programming
+ * error to set a value smaller than #GtdMaxSizeLayout:width-layout.
+ */
+void
+gtd_max_size_layout_set_max_width_chars (GtdMaxSizeLayout *self,
+                                         gint              max_width_chars)
+{
+  g_return_if_fail (GTD_IS_MAX_SIZE_LAYOUT (self));
+  g_return_if_fail (max_width_chars >= -1);
+  g_return_if_fail (self->width_chars == -1 || max_width_chars >= self->width_chars);
+
+  if (self->max_width_chars == max_width_chars)
+    return;
+
+  self->max_width_chars = max_width_chars;
+  gtk_layout_manager_layout_changed (GTK_LAYOUT_MANAGER (self));
+
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_MAX_WIDTH_CHARS]);
+}
+
+/**
+ * gtd_max_size_layout_get_width_chars:
+ *
+ * Retrieves the minimum width in characters of @self.
+ *
+ * Returns: minimum width in characters
+ */
+gint
+gtd_max_size_layout_get_width_chars (GtdMaxSizeLayout *self)
+{
+  g_return_val_if_fail (GTD_IS_MAX_SIZE_LAYOUT (self), -1);
+
+  return self->width_chars;
+}
+
+/**
+ * gtd_max_size_layout_set_width_chars:
+ * @self: a #GtdMaxSizeLayout
+ * @width_chars: minimum width of the widget @self is attached to, in character length
+ *
+ * Sets the minimum width @self has, in characters length. It is a programming
+ * error to set a value bigger than #GtdMaxSizeLayout:max-width-layout.
+ */
+void
+gtd_max_size_layout_set_width_chars (GtdMaxSizeLayout *self,
+                                     gint              width_chars)
+{
+  g_return_if_fail (GTD_IS_MAX_SIZE_LAYOUT (self));
+  g_return_if_fail (width_chars >= -1);
+  g_return_if_fail (self->max_width_chars == -1 || width_chars <= self->max_width_chars);
+
+  if (self->width_chars == width_chars)
+    return;
+
+  self->width_chars = width_chars;
+  gtk_layout_manager_layout_changed (GTK_LAYOUT_MANAGER (self));
+
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_WIDTH_CHARS]);
+}