[libhandy/wip/haecker-felix/flap-widget: 65/98] Start implementing new HdyFlap widget. Step one: Create C boilerplate code.
- From: Alexander Mikhaylenko <alexm src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [libhandy/wip/haecker-felix/flap-widget: 65/98] Start implementing new HdyFlap widget. Step one: Create C boilerplate code.
- Date: Mon, 3 Aug 2020 16:27:55 +0000 (UTC)
commit f41e995ebe81ab2a4a5400c882e5e6301ead51a1
Author: Felix Häcker <haeckerfelix gnome org>
Date: Mon Jul 27 14:22:51 2020 +0200
Start implementing new HdyFlap widget. Step one: Create C boilerplate code.
src/handy.h | 1 +
src/hdy-enums.c.in | 1 +
src/hdy-flap.c | 601 +++++++++++++++++++++++++++++++++++++++++++++++++++++
src/hdy-flap.h | 51 +++++
src/meson.build | 3 +
5 files changed, 657 insertions(+)
---
diff --git a/src/handy.h b/src/handy.h
index 73d8bbc7..624c635e 100644
--- a/src/handy.h
+++ b/src/handy.h
@@ -36,6 +36,7 @@ G_BEGIN_DECLS
#include "hdy-deprecation-macros.h"
#include "hdy-enum-value-object.h"
#include "hdy-expander-row.h"
+#include "hdy-flap.h"
#include "hdy-header-bar.h"
#include "hdy-header-group.h"
#include "hdy-keypad.h"
diff --git a/src/hdy-enums.c.in b/src/hdy-enums.c.in
index 9a9fe407..23d016fb 100644
--- a/src/hdy-enums.c.in
+++ b/src/hdy-enums.c.in
@@ -4,6 +4,7 @@
#include "hdy-carousel.h"
#include "hdy-deck.h"
#include "hdy-enums.h"
+#include "hdy-flap.h"
#include "hdy-header-bar.h"
#include "hdy-header-group.h"
#include "hdy-leaflet.h"
diff --git a/src/hdy-flap.c b/src/hdy-flap.c
new file mode 100644
index 00000000..50345895
--- /dev/null
+++ b/src/hdy-flap.c
@@ -0,0 +1,601 @@
+/*
+ * Copyright (C) 2020 Felix Häcker <haeckerfelix gnome org>
+ *
+ * SPDX-License-Identifier: LGPL-2.1+
+ */
+
+#include "config.h"
+#include "hdy-flap.h"
+
+#include <glib/gi18n-lib.h>
+#include <math.h>
+
+#include "hdy-animation-private.h"
+
+/**
+ * SECTION:hdy-flap
+ * @Title: HdyFlap
+ *
+ * Since: 1.0
+ */
+
+struct _HdyFlap
+{
+ GtkBin parent_instance;
+
+ GtkWidget* flap;
+ HdyFlapMode flap_mode;
+ GtkPackType flap_position;
+ gboolean reveal_flap;
+ gboolean overlay;
+
+ gint overlay_duration;
+ gint reveal_duration;
+
+ gint64 overlay_start_time;
+ guint overlay_tick_cb_id;
+ gdouble overlay_progress;
+ gint64 reveal_start_time;
+ guint reveal_tick_cb_id;
+ gdouble reveal_progress;
+
+ GtkOrientation orientation;
+};
+
+G_DEFINE_TYPE_WITH_CODE (HdyFlap, hdy_flap, GTK_TYPE_BIN,
+ G_IMPLEMENT_INTERFACE (GTK_TYPE_ORIENTABLE, NULL))
+
+enum {
+ PROP_0,
+
+ PROP_FLAP,
+ PROP_FLAP_MODE,
+ PROP_FLAP_POSITION,
+ PROP_REVEAL_FLAP,
+ PROP_OVERLAY,
+
+ PROP_OVERLAY_DURATION,
+ PROP_REVEAL_DURATION,
+
+ /* Overridden properties */
+ PROP_ORIENTATION,
+
+ LAST_PROP = PROP_REVEAL_DURATION + 1,
+};
+
+static GParamSpec *props[LAST_PROP];
+
+static void
+set_orientation (HdyFlap *self,
+ GtkOrientation orientation)
+{
+ if (self->orientation == orientation)
+ return;
+
+ self->orientation = orientation;
+ gtk_widget_queue_resize (GTK_WIDGET (self));
+ g_object_notify (G_OBJECT (self), "orientation");
+}
+
+static void
+hdy_flap_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ HdyFlap *self = HDY_FLAP (object);
+
+ switch (prop_id) {
+ case PROP_FLAP:
+ g_value_set_object (value, hdy_flap_get_flap (self));
+ break;
+ case PROP_FLAP_MODE:
+ g_value_set_enum (value, hdy_flap_get_flap_mode (self));
+ break;
+ case PROP_FLAP_POSITION:
+ g_value_set_enum (value, hdy_flap_get_flap_position (self));
+ break;
+ case PROP_REVEAL_FLAP:
+ g_value_set_boolean (value, hdy_flap_get_reveal_flap (self));
+ break;
+ case PROP_OVERLAY:
+ g_value_set_boolean (value, hdy_flap_get_overlay (self));
+ break;
+ case PROP_OVERLAY_DURATION:
+ g_value_set_int (value, hdy_flap_get_overlay_duration(self));
+ break;
+ case PROP_REVEAL_DURATION:
+ g_value_set_int (value, hdy_flap_get_reveal_duration(self));
+ break;
+ case PROP_ORIENTATION:
+ g_value_set_enum (value, self->orientation);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ }
+}
+
+static void
+hdy_flap_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ HdyFlap *self = HDY_FLAP (object);
+
+ switch (prop_id) {
+ case PROP_FLAP:
+ hdy_flap_set_flap (self, g_value_get_object (value));
+ break;
+ case PROP_FLAP_MODE:
+ hdy_flap_set_flap_mode (self, g_value_get_enum (value));
+ break;
+ case PROP_FLAP_POSITION:
+ hdy_flap_set_flap_position (self, g_value_get_enum (value));
+ break;
+ case PROP_REVEAL_FLAP:
+ hdy_flap_set_reveal_flap (self, g_value_get_boolean (value));
+ break;
+ case PROP_OVERLAY_DURATION:
+ hdy_flap_set_overlay_duration (self, g_value_get_int (value));
+ break;
+ case PROP_REVEAL_DURATION:
+ hdy_flap_set_reveal_duration (self, g_value_get_int (value));
+ break;
+ case PROP_ORIENTATION:
+ set_orientation (self, g_value_get_enum (value));
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ }
+}
+
+/* This private method is prefixed by the call name because it will be a virtual
+ * method in GTK 4.
+ */
+static void
+hdy_flap_measure (GtkWidget *widget,
+ GtkOrientation orientation,
+ int for_size,
+ int *minimum,
+ int *natural,
+ int *minimum_baseline,
+ int *natural_baseline)
+{
+ HdyFlap *self = HDY_FLAP (widget);
+ GtkBin *bin = GTK_BIN (widget);
+ GtkWidget *child;
+ gint child_size;
+}
+
+static void
+hdy_flap_get_preferred_width_for_height (GtkWidget *widget,
+ gint height,
+ gint *minimum,
+ gint *natural)
+{
+ hdy_flap_measure (widget, GTK_ORIENTATION_HORIZONTAL, height,
+ minimum, natural, NULL, NULL);
+}
+
+static void
+hdy_flap_get_preferred_width (GtkWidget *widget,
+ gint *minimum,
+ gint *natural)
+{
+ hdy_flap_measure (widget, GTK_ORIENTATION_HORIZONTAL, -1,
+ minimum, natural, NULL, NULL);
+}
+
+
+static void
+hdy_flap_get_preferred_height_for_width (GtkWidget *widget,
+ gint width,
+ gint *minimum,
+ gint *natural)
+{
+ hdy_flap_measure (widget, GTK_ORIENTATION_VERTICAL, width,
+ minimum, natural, NULL, NULL);
+}
+
+static void
+hdy_flap_get_preferred_height (GtkWidget *widget,
+ gint *minimum,
+ gint *natural)
+{
+ hdy_flap_measure (widget, GTK_ORIENTATION_VERTICAL, -1,
+ minimum, natural, NULL, NULL);
+}
+
+static void
+hdy_flap_size_allocate (GtkWidget *widget,
+ GtkAllocation *allocation)
+{
+ HdyFlap *self = HDY_FLAP (widget);
+ GtkBin *bin = GTK_BIN (widget);
+ GtkAllocation child_allocation;
+ gint baseline;
+ GtkWidget *child;
+ GtkStyleContext *context = gtk_widget_get_style_context (widget);
+ gint child_maximum = 0, lower_threshold = 0;
+ gint child_flaped_size;
+
+ gtk_widget_set_allocation (widget, allocation);
+}
+
+static void
+hdy_flap_class_init (HdyFlapClass *klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+ GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+ GtkContainerClass *container_class = GTK_CONTAINER_CLASS (klass);
+
+ object_class->get_property = hdy_flap_get_property;
+ object_class->set_property = hdy_flap_set_property;
+
+ widget_class->get_preferred_width = hdy_flap_get_preferred_width;
+ widget_class->get_preferred_width_for_height = hdy_flap_get_preferred_width_for_height;
+ widget_class->get_preferred_height = hdy_flap_get_preferred_height;
+ widget_class->get_preferred_height_for_width = hdy_flap_get_preferred_height_for_width;
+ widget_class->size_allocate = hdy_flap_size_allocate;
+
+ gtk_container_class_handle_border_width (container_class);
+
+ g_object_class_override_property (object_class,
+ PROP_ORIENTATION,
+ "orientation");
+
+ /**
+ * HdyFlap:flap:
+ *
+ * Since: 1.0
+ */
+ props[PROP_FLAP] =
+ g_param_spec_object ("flap",
+ _("Flap widget"),
+ _("Flap Widget"),
+ GTK_TYPE_WIDGET,
+ G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY);
+
+ /**
+ * HdyFlap:flap-mode:
+ *
+ * Since: 1.0
+ */
+ props[PROP_FLAP_MODE] =
+ g_param_spec_enum ("flap-mode",
+ _("Flap Mode"),
+ _("Flap Mode"),
+ HDY_TYPE_FLAP_MODE,
+ HDY_FLAP_MODE_NON_OVERLAY,
+ G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY);
+
+ /**
+ * HdyFlap:flap-position:
+ *
+ * Since: 1.0
+ */
+ props[PROP_FLAP_POSITION] =
+ g_param_spec_enum ("flap-position",
+ _("Flap Position"),
+ _("Flap Position"),
+ GTK_TYPE_PACK_TYPE,
+ GTK_PACK_START,
+ G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY);
+
+ /**
+ * HdyFlap:reveal-flap:
+ *
+ * Since: 1.0
+ */
+ props[PROP_FLAP_POSITION] =
+ g_param_spec_boolean ("reveal-flap",
+ _("Reveal Flap"),
+ _("Reveal Flap"),
+ TRUE,
+ G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY);
+
+ /**
+ * HdyFlap:overlay:
+ *
+ * Since: 1.0
+ */
+ props[PROP_FLAP_POSITION] =
+ g_param_spec_boolean ("overlay",
+ _("Overlay"),
+ _("Overlay"),
+ FALSE,
+ G_PARAM_READABLE | G_PARAM_EXPLICIT_NOTIFY);
+
+ /**
+ * HdyFlap:overlay-duration:
+ *
+ * Since: 1.0
+ */
+ props[PROP_FLAP_POSITION] =
+ g_param_spec_int ("overlay-duration",
+ _("Overlay Duration"),
+ _("Overlay Duration"),
+ 0, G_MAXINT,
+ 250,
+ G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY);
+
+ /**
+ * HdyFlap:reveal-duration:
+ *
+ * Since: 1.0
+ */
+ props[PROP_FLAP_POSITION] =
+ g_param_spec_int ("reveal-duration",
+ _("Reveal Duration"),
+ _("Reveal Duration"),
+ 0, G_MAXINT,
+ 250,
+ G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY);
+
+ g_object_class_install_properties (object_class, LAST_PROP, props);
+
+ gtk_widget_class_set_css_name (widget_class, "flap");
+}
+
+static void
+hdy_flap_init (HdyFlap *self)
+{
+ self->flap_position = GTK_PACK_START;
+ self->orientation = GTK_ORIENTATION_HORIZONTAL;
+ self->overlay_duration = 250;
+ self->reveal_duration = 250;
+}
+
+/**
+ * hdy_flap_new:
+ *
+ * Creates a new #HdyFlap.
+ *
+ * Returns: a new #HdyFlap
+ *
+ * Since: 1.0
+ */
+GtkWidget *
+hdy_flap_new (void)
+{
+ return g_object_new (HDY_TYPE_FLAP, NULL);
+}
+
+/**
+ * hdy_flap_get_flap:
+ * @self: a #HdyFlap
+ *
+ * Returns: Flap child.
+ *
+ * Since: 1.0
+ */
+GtkWidget *
+hdy_flap_get_flap (HdyFlap *self)
+{
+ g_return_val_if_fail (HDY_IS_FLAP (self), NULL);
+
+ return self->flap;
+}
+
+/**
+ * hdy_flap_set_flap:
+ * @self: a #HdyFlap
+ * @flap: flap widget
+ *
+ * Since: 1.0
+ */
+void
+hdy_flap_set_flap (HdyFlap *self,
+ GtkWidget *flap)
+{
+ g_return_if_fail (HDY_IS_FLAP (self));
+
+ if (self->flap == flap)
+ return;
+
+ self->flap = flap;
+
+ g_object_notify_by_pspec (G_OBJECT (self), props[PROP_FLAP]);
+}
+
+/**
+ * hdy_flap_get_flap_mode:
+ * @self: a #HdyFlap
+ *
+ * Returns: current flap mode.
+ *
+ * Since: 1.0
+ */
+HdyFlapMode
+hdy_flap_get_flap_mode (HdyFlap *self)
+{
+ g_return_val_if_fail (HDY_IS_FLAP (self), FALSE);
+
+ return self->flap_mode;
+}
+
+/**
+ * hdy_flap_set_flap_mode:
+ * @self: a #HdyFlap
+ * @flap_mode: Flap mode
+ *
+ * Since: 1.0
+ */
+void
+hdy_flap_set_flap_mode (HdyFlap *self,
+ HdyFlapMode flap_mode)
+{
+ g_return_if_fail (HDY_IS_FLAP (self));
+
+ if (self->flap_mode == flap_mode)
+ return;
+
+ self->flap_mode = flap_mode;
+
+ g_object_notify_by_pspec (G_OBJECT (self), props[PROP_FLAP_MODE]);
+}
+
+/**
+ * hdy_flap_get_flap_position:
+ * @self: a #HdyFlap
+ *
+ * Returns: current flap position.
+ *
+ * Since: 1.0
+ */
+GtkPackType
+hdy_flap_get_flap_position (HdyFlap *self)
+{
+ g_return_val_if_fail (HDY_IS_FLAP (self), FALSE);
+
+ return self->flap_position;
+}
+
+/**
+ * hdy_flap_set_flap_position:
+ * @self: a #HdyFlap
+ * @flap_position: Flap position
+ *
+ * Since: 1.0
+ */
+void
+hdy_flap_set_flap_position (HdyFlap *self,
+ GtkPackType flap_position)
+{
+ g_return_if_fail (HDY_IS_FLAP (self));
+
+ if (self->flap_position == flap_position)
+ return;
+
+ self->flap_position = flap_position;
+
+ g_object_notify_by_pspec (G_OBJECT (self), props[PROP_FLAP_POSITION]);
+}
+
+/**
+ * hdy_flap_get_reveal_flap:
+ * @self: a #HdyFlap
+ *
+ * Returns: %TRUE if flap widget gets revealed.
+ *
+ * Since: 1.0
+ */
+gboolean
+hdy_flap_get_reveal_flap (HdyFlap *self)
+{
+ g_return_val_if_fail (HDY_IS_FLAP (self), FALSE);
+
+ return self->reveal_flap;
+}
+
+/**
+ * hdy_flap_set_reveal_flap:
+ * @self: a #HdyFlap
+ * @reveal_flap: Reveal flap
+ *
+ * Since: 1.0
+ */
+void
+hdy_flap_set_reveal_flap (HdyFlap *self,
+ gboolean reveal_flap)
+{
+ g_return_if_fail (HDY_IS_FLAP (self));
+
+ if (self->reveal_flap == reveal_flap)
+ return;
+
+ self->reveal_flap = reveal_flap;
+
+ g_object_notify_by_pspec (G_OBJECT (self), props[PROP_REVEAL_FLAP]);
+}
+
+/**
+ * hdy_flap_get_overlay:
+ * @self: a #HdyFlap
+ *
+ * Returns: %TRUE if flap widget gets overlayed.
+ *
+ * Since: 1.0
+ */
+gboolean
+hdy_flap_get_overlay (HdyFlap *self)
+{
+ g_return_val_if_fail (HDY_IS_FLAP (self), FALSE);
+
+ return self->overlay;
+}
+
+/**
+ * hdy_flap_get_overlay_duration:
+ * @self: a #HdyFlap
+ *
+ * Returns: current overlay animation duration.
+ *
+ * Since: 1.0
+ */
+gint
+hdy_flap_get_overlay_duration (HdyFlap *self)
+{
+ g_return_val_if_fail (HDY_IS_FLAP (self), 0);
+
+ return self->overlay_duration;
+}
+
+/**
+ * hdy_flap_set_overlay_duration:
+ * @self: a #HdyFlap
+ * @overlay_duration: Duration for overlay animation
+ *
+ * Since: 1.0
+ */
+void
+hdy_flap_set_overlay_duration (HdyFlap *self,
+ gint overlay_duration)
+{
+ g_return_if_fail (HDY_IS_FLAP (self));
+
+ if (self->overlay_duration == overlay_duration)
+ return;
+
+ self->overlay_duration = overlay_duration;
+
+ g_object_notify_by_pspec (G_OBJECT (self), props[PROP_OVERLAY_DURATION]);
+}
+
+/**
+ * hdy_flap_get_reveal_duration:
+ * @self: a #HdyFlap
+ *
+ * Returns: current reveal animation duration.
+ *
+ * Since: 1.0
+ */
+gint
+hdy_flap_get_reveal_duration (HdyFlap *self)
+{
+ g_return_val_if_fail (HDY_IS_FLAP (self), 0);
+
+ return self->reveal_duration;
+}
+
+/**
+ * hdy_flap_set_reveal_duration:
+ * @self: a #HdyFlap
+ * @reveal_duration: Duration for overlay animation
+ *
+ * Since: 1.0
+ */
+void
+hdy_flap_set_reveal_duration (HdyFlap *self,
+ gint reveal_duration)
+{
+ g_return_if_fail (HDY_IS_FLAP (self));
+
+ if (self->reveal_duration == reveal_duration)
+ return;
+
+ self->reveal_duration = reveal_duration;
+
+ g_object_notify_by_pspec (G_OBJECT (self), props[PROP_REVEAL_DURATION]);
+}
diff --git a/src/hdy-flap.h b/src/hdy-flap.h
new file mode 100644
index 00000000..02070767
--- /dev/null
+++ b/src/hdy-flap.h
@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2020 Felix Häcker <haeckerfelix gnome org>
+ *
+ * SPDX-License-Identifier: LGPL-2.1+
+ */
+
+#pragma once
+
+#if !defined(_HANDY_INSIDE) && !defined(HANDY_COMPILATION)
+#error "Only <handy.h> can be included directly."
+#endif
+
+#include <gtk/gtk.h>
+#include "hdy-enums.h"
+
+G_BEGIN_DECLS
+
+#define HDY_TYPE_FLAP (hdy_flap_get_type())
+
+G_DECLARE_FINAL_TYPE (HdyFlap, hdy_flap, HDY, FLAP, GtkBin)
+
+typedef enum {
+ HDY_FLAP_MODE_NON_OVERLAY,
+ HDY_FLAP_MODE_OVERLAY,
+ HDY_FLAP_MODE_AUTO,
+} HdyFlapMode;
+
+
+GtkWidget *hdy_flap_new (void);
+
+GtkWidget *hdy_flap_get_flap (HdyFlap *self);
+void hdy_flap_set_flap (HdyFlap *self,
+ GtkWidget *flap);
+HdyFlapMode hdy_flap_get_flap_mode (HdyFlap *self);
+void hdy_flap_set_flap_mode (HdyFlap *self,
+ HdyFlapMode flap_mode);
+GtkPackType hdy_flap_get_flap_position (HdyFlap *self);
+void hdy_flap_set_flap_position (HdyFlap *self,
+ GtkPackType flap_position);
+gboolean hdy_flap_get_reveal_flap (HdyFlap *self);
+void hdy_flap_set_reveal_flap (HdyFlap *self,
+ gboolean reveal_flap);
+gboolean hdy_flap_get_overlay (HdyFlap *self);
+gint hdy_flap_get_overlay_duration (HdyFlap *self);
+void hdy_flap_set_overlay_duration (HdyFlap *self,
+ gint overlay_duration);
+gint hdy_flap_get_reveal_duration (HdyFlap *self);
+void hdy_flap_set_reveal_duration (HdyFlap *self,
+ gint reveal_duration);
+
+G_END_DECLS
diff --git a/src/meson.build b/src/meson.build
index 2356bf6e..904255dd 100644
--- a/src/meson.build
+++ b/src/meson.build
@@ -10,6 +10,7 @@ libhandy_resources = gnome.compile_resources(
hdy_public_enum_headers = [
'hdy-carousel.h',
'hdy-deck.h',
+ 'hdy-flap.h',
'hdy-header-bar.h',
'hdy-header-group.h',
'hdy-leaflet.h',
@@ -77,6 +78,7 @@ src_headers = [
'hdy-deprecation-macros.h',
'hdy-enum-value-object.h',
'hdy-expander-row.h',
+ 'hdy-flap.h',
'hdy-header-bar.h',
'hdy-header-group.h',
'hdy-keypad.h',
@@ -126,6 +128,7 @@ src_sources = [
'hdy-deck.c',
'hdy-enum-value-object.c',
'hdy-expander-row.c',
+ 'hdy-flap.c',
'hdy-header-bar.c',
'hdy-header-group.c',
'hdy-keypad-button.c',
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
