From af3b0eea028832656ae9d46b54ef62cb2e1e483d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pablo=20Correa=20G=C3=B3mez?= Date: Fri, 27 Dec 2024 20:10:12 +0100 Subject: [PATCH 1/5] libdocument: place definitions for PpsAnnotationStamp consistently In between PpsAnnotationText and PpsAnnotationFreeText --- libdocument/pps-annotation.c | 151 +++++++++++++++++------------------ libdocument/pps-annotation.h | 26 +++--- 2 files changed, 88 insertions(+), 89 deletions(-) diff --git a/libdocument/pps-annotation.c b/libdocument/pps-annotation.c index 052c71f10..a6b079ee3 100644 --- a/libdocument/pps-annotation.c +++ b/libdocument/pps-annotation.c @@ -1184,81 +1184,6 @@ pps_annotation_markup_set_popup_is_open (PpsAnnotationMarkup *markup, return TRUE; } -/* PpsAnnotationStamp */ -static void -pps_annotation_stamp_init (PpsAnnotationStamp *annot) -{ - PpsAnnotationPrivate *priv = GET_ANNOT_PRIVATE (PPS_ANNOTATION (annot)); - - priv->type = PPS_ANNOTATION_TYPE_STAMP; -} - -static void -pps_annotation_stamp_dispose (GObject *object) -{ - PpsAnnotationStampPrivate *priv = GET_ANNOT_STAMP_PRIVATE (PPS_ANNOTATION_STAMP (object)); - - g_clear_pointer (&priv->surface, cairo_surface_destroy); - - G_OBJECT_CLASS (pps_annotation_stamp_parent_class)->dispose (object); -} - -static void -pps_annotation_stamp_class_init (PpsAnnotationStampClass *klass) -{ - G_OBJECT_CLASS (klass)->dispose = pps_annotation_stamp_dispose; -} - -/** - * pps_annotation_stamp_set_surface: - * @stamp: an #PpsAnnotationStamp - * @surface: a #cairo_surface_t - * - * Set the custom cairo surface of the stamp. - * - * Since: 48.0 - */ -void -pps_annotation_stamp_set_surface (PpsAnnotationStamp *stamp, cairo_surface_t *surface) -{ - PpsAnnotationStampPrivate *priv = GET_ANNOT_STAMP_PRIVATE (stamp); - priv->surface = cairo_surface_reference (surface); -} - -/** - * pps_annotation_stamp_get_surface: - * @stamp: an #PpsAnnotationStamp - * - * Set the custom cairo surface of the stamp. - * - * Returns: (transfer none): the custom cairo surface of the stamp, if it exists. - * Since: 48.0 - */ -cairo_surface_t * -pps_annotation_stamp_get_surface (PpsAnnotationStamp *stamp) -{ - PpsAnnotationStampPrivate *priv = GET_ANNOT_STAMP_PRIVATE (stamp); - return priv->surface; -} - -/** - * pps_annotation_stamp_new: - * @page: a #PpsPage - * - * Creates a new stamp annotation. ATM only the custom image type via - * #pps_annotation_stamp_set_surface is implemented, other stamps (draft, etc.) - * are not. - * - * Since: 48.0 - */ -PpsAnnotation * -pps_annotation_stamp_new (PpsPage *page) -{ - return PPS_ANNOTATION (g_object_new (PPS_TYPE_ANNOTATION_STAMP, - "page", page, - NULL)); -} - /* PpsAnnotationText */ static void pps_annotation_text_init (PpsAnnotationText *annot) @@ -1417,8 +1342,82 @@ pps_annotation_text_set_is_open (PpsAnnotationText *text, return TRUE; } -/* PpsAnnotationFreeText */ +/* PpsAnnotationStamp */ +static void +pps_annotation_stamp_init (PpsAnnotationStamp *annot) +{ + PpsAnnotationPrivate *priv = GET_ANNOT_PRIVATE (PPS_ANNOTATION (annot)); + + priv->type = PPS_ANNOTATION_TYPE_STAMP; +} + +static void +pps_annotation_stamp_dispose (GObject *object) +{ + PpsAnnotationStampPrivate *priv = GET_ANNOT_STAMP_PRIVATE (PPS_ANNOTATION_STAMP (object)); + + g_clear_pointer (&priv->surface, cairo_surface_destroy); + + G_OBJECT_CLASS (pps_annotation_stamp_parent_class)->dispose (object); +} + +static void +pps_annotation_stamp_class_init (PpsAnnotationStampClass *klass) +{ + G_OBJECT_CLASS (klass)->dispose = pps_annotation_stamp_dispose; +} +/** + * pps_annotation_stamp_set_surface: + * @stamp: an #PpsAnnotationStamp + * @surface: a #cairo_surface_t + * + * Set the custom cairo surface of the stamp. + * + * Since: 48.0 + */ +void +pps_annotation_stamp_set_surface (PpsAnnotationStamp *stamp, cairo_surface_t *surface) +{ + PpsAnnotationStampPrivate *priv = GET_ANNOT_STAMP_PRIVATE (stamp); + priv->surface = cairo_surface_reference (surface); +} + +/** + * pps_annotation_stamp_get_surface: + * @stamp: an #PpsAnnotationStamp + * + * Set the custom cairo surface of the stamp. + * + * Returns: (transfer none): the custom cairo surface of the stamp, if it exists. + * Since: 48.0 + */ +cairo_surface_t * +pps_annotation_stamp_get_surface (PpsAnnotationStamp *stamp) +{ + PpsAnnotationStampPrivate *priv = GET_ANNOT_STAMP_PRIVATE (stamp); + return priv->surface; +} + +/** + * pps_annotation_stamp_new: + * @page: a #PpsPage + * + * Creates a new stamp annotation. ATM only the custom image type via + * #pps_annotation_stamp_set_surface is implemented, other stamps (draft, etc.) + * are not. + * + * Since: 48.0 + */ +PpsAnnotation * +pps_annotation_stamp_new (PpsPage *page) +{ + return PPS_ANNOTATION (g_object_new (PPS_TYPE_ANNOTATION_STAMP, + "page", page, + NULL)); +} + +/* PpsAnnotationFreeText */ static void pps_annotation_free_text_init (PpsAnnotationFreeText *annot) { diff --git a/libdocument/pps-annotation.h b/libdocument/pps-annotation.h index 953901f48..604b72ba3 100644 --- a/libdocument/pps-annotation.h +++ b/libdocument/pps-annotation.h @@ -49,16 +49,16 @@ struct _PpsAnnotationClass { PPS_PUBLIC G_DECLARE_INTERFACE (PpsAnnotationMarkup, pps_annotation_markup, PPS, ANNOTATION_MARKUP, GObject); -/* PpsAnnotationStamp */ -#define PPS_TYPE_ANNOTATION_STAMP (pps_annotation_stamp_get_type ()) -PPS_PUBLIC -G_DECLARE_FINAL_TYPE (PpsAnnotationStamp, pps_annotation_stamp, PPS, ANNOTATION_STAMP, PpsAnnotation); - /* PpsAnnotationText */ #define PPS_TYPE_ANNOTATION_TEXT (pps_annotation_text_get_type ()) PPS_PUBLIC G_DECLARE_FINAL_TYPE (PpsAnnotationText, pps_annotation_text, PPS, ANNOTATION_TEXT, PpsAnnotation); +/* PpsAnnotationStamp */ +#define PPS_TYPE_ANNOTATION_STAMP (pps_annotation_stamp_get_type ()) +PPS_PUBLIC +G_DECLARE_FINAL_TYPE (PpsAnnotationStamp, pps_annotation_stamp, PPS, ANNOTATION_STAMP, PpsAnnotation); + /* PpsAnnotationFreeText */ #define PPS_TYPE_ANNOTATION_FREE_TEXT (pps_annotation_free_text_get_type ()) PPS_PUBLIC @@ -158,14 +158,6 @@ PPS_PUBLIC gboolean pps_annotation_set_area (PpsAnnotation *annot, const PpsRectangle *area); -/* PpsAnnotationStamp */ -PPS_PUBLIC -PpsAnnotation *pps_annotation_stamp_new (PpsPage *page); -PPS_PUBLIC -void pps_annotation_stamp_set_surface (PpsAnnotationStamp *stamp, cairo_surface_t *surface); -PPS_PUBLIC -cairo_surface_t *pps_annotation_stamp_get_surface (PpsAnnotationStamp *stamp); - /* PpsAnnotationMarkup */ PPS_PUBLIC const gchar *pps_annotation_markup_get_label (PpsAnnotationMarkup *markup); @@ -210,6 +202,14 @@ PPS_PUBLIC gboolean pps_annotation_text_set_is_open (PpsAnnotationText *text, gboolean is_open); +/* PpsAnnotationStamp */ +PPS_PUBLIC +PpsAnnotation *pps_annotation_stamp_new (PpsPage *page); +PPS_PUBLIC +void pps_annotation_stamp_set_surface (PpsAnnotationStamp *stamp, cairo_surface_t *surface); +PPS_PUBLIC +cairo_surface_t *pps_annotation_stamp_get_surface (PpsAnnotationStamp *stamp); + /* PpsAnnotationFreeText */ PPS_PUBLIC PpsAnnotation *pps_annotation_free_text_new (PpsPage *page); -- GitLab From e5c3c6eb8cf68afa7fff3eb93d28471a71018295 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pablo=20Correa=20G=C3=B3mez?= Date: Fri, 27 Dec 2024 20:12:08 +0100 Subject: [PATCH 2/5] libdocument: make PpsAnnotationMarkup a class instead of an interface It is already effectively one, since the markup interface is empty, and it holds several properties which are not set by the implementers. --- libdocument/pps-annotation.c | 433 +++++++++++++---------------------- libdocument/pps-annotation.h | 6 +- 2 files changed, 169 insertions(+), 270 deletions(-) diff --git a/libdocument/pps-annotation.c b/libdocument/pps-annotation.c index a6b079ee3..6c10efea9 100644 --- a/libdocument/pps-annotation.c +++ b/libdocument/pps-annotation.c @@ -44,11 +44,18 @@ G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (PpsAnnotation, pps_annotation, G_TYPE_OBJEC #define GET_ANNOT_PRIVATE(o) pps_annotation_get_instance_private (o) /* PpsAnnotationMarkup*/ -struct _PpsAnnotationMarkupInterface { - GTypeInterface base_iface; -}; +typedef struct +{ + gchar *label; + gdouble opacity; + gboolean can_have_popup; + gboolean has_popup; + gboolean popup_is_open; + PpsRectangle rectangle; +} PpsAnnotationMarkupPrivate; -G_DEFINE_INTERFACE (PpsAnnotationMarkup, pps_annotation_markup, PPS_TYPE_ANNOTATION); +G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (PpsAnnotationMarkup, pps_annotation_markup, PPS_TYPE_ANNOTATION); +#define GET_ANNOT_MARKUP_PRIVATE(o) pps_annotation_markup_get_instance_private (o) /* PpsAnnotationText*/ typedef struct @@ -61,14 +68,9 @@ struct _PpsAnnotationText { PpsAnnotation parent; }; -static void pps_annotation_text_markup_iface_init (PpsAnnotationMarkupInterface *iface); - -G_DEFINE_TYPE_WITH_CODE (PpsAnnotationText, - pps_annotation_text, - PPS_TYPE_ANNOTATION, - G_IMPLEMENT_INTERFACE (PPS_TYPE_ANNOTATION_MARKUP, - pps_annotation_text_markup_iface_init) - G_ADD_PRIVATE (PpsAnnotationText)); +G_DEFINE_TYPE_WITH_PRIVATE (PpsAnnotationText, + pps_annotation_text, + PPS_TYPE_ANNOTATION_MARKUP); #define GET_ANNOT_TEXT_PRIVATE(o) pps_annotation_text_get_instance_private (o) /* PpsAnnotationStamp */ @@ -113,14 +115,9 @@ struct _PpsAnnotationAttachment { PpsAnnotation parent; }; -static void pps_annotation_attachment_markup_iface_init (PpsAnnotationMarkupInterface *iface); - -G_DEFINE_TYPE_WITH_CODE (PpsAnnotationAttachment, - pps_annotation_attachment, - PPS_TYPE_ANNOTATION, - G_IMPLEMENT_INTERFACE (PPS_TYPE_ANNOTATION_MARKUP, - pps_annotation_attachment_markup_iface_init) - G_ADD_PRIVATE (PpsAnnotationAttachment)); +G_DEFINE_TYPE_WITH_PRIVATE (PpsAnnotationAttachment, + pps_annotation_attachment, + PPS_TYPE_ANNOTATION_MARKUP); #define GET_ANNOT_ATTACH_PRIVATE(o) pps_annotation_attachment_get_instance_private (o) /* PpsAnnotationTextMarkup */ @@ -133,14 +130,9 @@ struct _PpsAnnotationTextMarkup { PpsAnnotation parent; }; -static void pps_annotation_text_markup_markup_iface_init (PpsAnnotationMarkupInterface *iface); - -G_DEFINE_TYPE_WITH_CODE (PpsAnnotationTextMarkup, - pps_annotation_text_markup, - PPS_TYPE_ANNOTATION, - G_IMPLEMENT_INTERFACE (PPS_TYPE_ANNOTATION_MARKUP, - pps_annotation_text_markup_markup_iface_init) - G_ADD_PRIVATE (PpsAnnotationTextMarkup)); +G_DEFINE_TYPE_WITH_PRIVATE (PpsAnnotationTextMarkup, + pps_annotation_text_markup, + PPS_TYPE_ANNOTATION_MARKUP); #define GET_ANNOT_TEXT_MARKUP_PRIVATE(o) pps_annotation_text_markup_get_instance_private (o) /* PpsAnnotation */ @@ -169,18 +161,18 @@ enum { /* PpsAnnotationText */ enum { - PROP_TEXT_ICON = PROP_MARKUP_POPUP_IS_OPEN + 1, + PROP_TEXT_ICON = 1, PROP_TEXT_IS_OPEN }; /* PpsAnnotationAttachment */ enum { - PROP_ATTACHMENT_ATTACHMENT = PROP_MARKUP_POPUP_IS_OPEN + 1 + PROP_ATTACHMENT_ATTACHMENT = 1 }; /* PpsAnnotationTextMarkup */ enum { - PROP_TEXT_MARKUP_TYPE = PROP_MARKUP_POPUP_IS_OPEN + 1 + PROP_TEXT_MARKUP_TYPE = 1 }; /* PpsAnnotationFreeText */ @@ -835,99 +827,14 @@ pps_annotation_get_border_width (PpsAnnotation *annot) } /* PpsAnnotationMarkup */ -typedef struct -{ - gchar *label; - gdouble opacity; - gboolean can_have_popup; - gboolean has_popup; - gboolean popup_is_open; - PpsRectangle rectangle; -} PpsAnnotationMarkupProps; - -static void -pps_annotation_markup_default_init (PpsAnnotationMarkupInterface *iface) -{ - static gboolean initialized = FALSE; - - if (!initialized) { - g_object_interface_install_property (iface, - g_param_spec_string ("label", - "Label", - "Label of the markup annotation", - NULL, - G_PARAM_READWRITE | - G_PARAM_STATIC_STRINGS)); - g_object_interface_install_property (iface, - g_param_spec_double ("opacity", - "Opacity", - "Opacity of the markup annotation", - 0, - G_MAXDOUBLE, - 1., - G_PARAM_READWRITE | - G_PARAM_STATIC_STRINGS)); - g_object_interface_install_property (iface, - g_param_spec_boolean ("can-have-popup", - "Can have popup", - "Whether it is allowed to have a popup " - "window for this type of markup annotation", - FALSE, - G_PARAM_READWRITE | - G_PARAM_STATIC_STRINGS)); - g_object_interface_install_property (iface, - g_param_spec_boolean ("has-popup", - "Has popup", - "Whether the markup annotation has " - "a popup window associated", - TRUE, - G_PARAM_READWRITE | - G_PARAM_STATIC_STRINGS)); - g_object_interface_install_property (iface, - g_param_spec_boxed ("rectangle", - "Rectangle", - "The Rectangle of the popup associated " - "to the markup annotation", - PPS_TYPE_RECTANGLE, - G_PARAM_READWRITE | - G_PARAM_STATIC_STRINGS)); - g_object_interface_install_property (iface, - g_param_spec_boolean ("popup-is-open", - "PopupIsOpen", - "Whether the popup associated to " - "the markup annotation is open", - FALSE, - G_PARAM_READWRITE | - G_PARAM_STATIC_STRINGS)); - initialized = TRUE; - } -} - static void -pps_annotation_markup_props_free (PpsAnnotationMarkupProps *props) +pps_annotation_markup_dispose (GObject *object) { - g_free (props->label); - g_slice_free (PpsAnnotationMarkupProps, props); -} - -static PpsAnnotationMarkupProps * -pps_annotation_markup_get_properties (PpsAnnotationMarkup *markup) -{ - PpsAnnotationMarkupProps *props; - static GQuark props_key = 0; + PpsAnnotationMarkupPrivate *priv = GET_ANNOT_MARKUP_PRIVATE (PPS_ANNOTATION_MARKUP (object)); - if (!props_key) - props_key = g_quark_from_static_string ("pps-annotation-markup-props"); - - props = g_object_get_qdata (G_OBJECT (markup), props_key); - if (!props) { - props = g_slice_new0 (PpsAnnotationMarkupProps); - g_object_set_qdata_full (G_OBJECT (markup), - props_key, props, - (GDestroyNotify) pps_annotation_markup_props_free); - } + g_free (priv->label); - return props; + G_OBJECT_CLASS (pps_annotation_markup_parent_class)->dispose (object); } static void @@ -936,30 +843,28 @@ pps_annotation_markup_set_property (GObject *object, const GValue *value, GParamSpec *pspec) { - PpsAnnotationMarkup *markup = PPS_ANNOTATION_MARKUP (object); + PpsAnnotationMarkup *self = PPS_ANNOTATION_MARKUP (object); + PpsAnnotationMarkupPrivate *priv = GET_ANNOT_MARKUP_PRIVATE (self); switch (prop_id) { case PROP_MARKUP_LABEL: - pps_annotation_markup_set_label (markup, g_value_get_string (value)); + pps_annotation_markup_set_label (self, g_value_get_string (value)); break; case PROP_MARKUP_OPACITY: - pps_annotation_markup_set_opacity (markup, g_value_get_double (value)); + pps_annotation_markup_set_opacity (self, g_value_get_double (value)); break; case PROP_MARKUP_CAN_HAVE_POPUP: { - PpsAnnotationMarkupProps *props; - - props = pps_annotation_markup_get_properties (markup); - props->can_have_popup = g_value_get_boolean (value); + priv->can_have_popup = g_value_get_boolean (value); break; } case PROP_MARKUP_HAS_POPUP: - pps_annotation_markup_set_has_popup (markup, g_value_get_boolean (value)); + pps_annotation_markup_set_has_popup (self, g_value_get_boolean (value)); break; case PROP_MARKUP_RECTANGLE: - pps_annotation_markup_set_rectangle (markup, g_value_get_boxed (value)); + pps_annotation_markup_set_rectangle (self, g_value_get_boxed (value)); break; case PROP_MARKUP_POPUP_IS_OPEN: - pps_annotation_markup_set_popup_is_open (markup, g_value_get_boolean (value)); + pps_annotation_markup_set_popup_is_open (self, g_value_get_boolean (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); @@ -972,28 +877,27 @@ pps_annotation_markup_get_property (GObject *object, GValue *value, GParamSpec *pspec) { - PpsAnnotationMarkupProps *props; - - props = pps_annotation_markup_get_properties (PPS_ANNOTATION_MARKUP (object)); + PpsAnnotationMarkup *self = PPS_ANNOTATION_MARKUP (object); + PpsAnnotationMarkupPrivate *priv = GET_ANNOT_MARKUP_PRIVATE (self); switch (prop_id) { case PROP_MARKUP_LABEL: - g_value_set_string (value, props->label); + g_value_set_string (value, priv->label); break; case PROP_MARKUP_OPACITY: - g_value_set_double (value, props->opacity); + g_value_set_double (value, priv->opacity); break; case PROP_MARKUP_CAN_HAVE_POPUP: - g_value_set_boolean (value, props->can_have_popup); + g_value_set_boolean (value, priv->can_have_popup); break; case PROP_MARKUP_HAS_POPUP: - g_value_set_boolean (value, props->has_popup); + g_value_set_boolean (value, priv->has_popup); break; case PROP_MARKUP_RECTANGLE: - g_value_set_boxed (value, &props->rectangle); + g_value_set_boxed (value, &priv->rectangle); break; case PROP_MARKUP_POPUP_IS_OPEN: - g_value_set_boolean (value, props->popup_is_open); + g_value_set_boolean (value, priv->popup_is_open); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); @@ -1001,185 +905,227 @@ pps_annotation_markup_get_property (GObject *object, } static void -pps_annotation_markup_class_install_properties (GObjectClass *klass) +pps_annotation_markup_init (PpsAnnotationMarkup *self) +{ +} + +static void +pps_annotation_markup_class_init (PpsAnnotationMarkupClass *klass) { - klass->set_property = pps_annotation_markup_set_property; - klass->get_property = pps_annotation_markup_get_property; + GObjectClass *g_object_class = G_OBJECT_CLASS (klass); + + g_object_class->dispose = pps_annotation_markup_dispose; + g_object_class->set_property = pps_annotation_markup_set_property; + g_object_class->get_property = pps_annotation_markup_get_property; - g_object_class_override_property (klass, PROP_MARKUP_LABEL, "label"); - g_object_class_override_property (klass, PROP_MARKUP_OPACITY, "opacity"); - g_object_class_override_property (klass, PROP_MARKUP_CAN_HAVE_POPUP, "can-have-popup"); - g_object_class_override_property (klass, PROP_MARKUP_HAS_POPUP, "has-popup"); - g_object_class_override_property (klass, PROP_MARKUP_RECTANGLE, "rectangle"); - g_object_class_override_property (klass, PROP_MARKUP_POPUP_IS_OPEN, "popup-is-open"); + g_object_class_install_property (g_object_class, + PROP_MARKUP_LABEL, + g_param_spec_string ("label", + "Label", + "Label of the markup annotation", + NULL, + G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + g_object_class_install_property (g_object_class, + PROP_MARKUP_OPACITY, + g_param_spec_double ("opacity", + "Opacity", + "Opacity of the markup annotation", + 0, + G_MAXDOUBLE, + 1., + G_PARAM_READWRITE | + G_PARAM_STATIC_STRINGS)); + g_object_class_install_property (g_object_class, + PROP_MARKUP_CAN_HAVE_POPUP, + g_param_spec_boolean ("can-have-popup", + "Can have popup", + "Whether it is allowed to have a popup " + "window for this type of markup annotation", + FALSE, + G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); + g_object_class_install_property (g_object_class, + PROP_MARKUP_HAS_POPUP, + g_param_spec_boolean ("has-popup", + "Has popup", + "Whether the markup annotation has " + "a popup window associated", + TRUE, + G_PARAM_READWRITE | + G_PARAM_STATIC_STRINGS)); + g_object_class_install_property (g_object_class, + PROP_MARKUP_RECTANGLE, + g_param_spec_boxed ("rectangle", + "Rectangle", + "The Rectangle of the popup associated " + "to the markup annotation", + PPS_TYPE_RECTANGLE, + G_PARAM_READWRITE | + G_PARAM_STATIC_STRINGS)); + g_object_class_install_property (g_object_class, + PROP_MARKUP_POPUP_IS_OPEN, + g_param_spec_boolean ("popup-is-open", + "PopupIsOpen", + "Whether the popup associated to " + "the markup annotation is open", + FALSE, + G_PARAM_READWRITE | + G_PARAM_STATIC_STRINGS)); } const gchar * -pps_annotation_markup_get_label (PpsAnnotationMarkup *markup) +pps_annotation_markup_get_label (PpsAnnotationMarkup *self) { - PpsAnnotationMarkupProps *props; + PpsAnnotationMarkupPrivate *priv = GET_ANNOT_MARKUP_PRIVATE (self); - g_return_val_if_fail (PPS_IS_ANNOTATION_MARKUP (markup), NULL); + g_return_val_if_fail (PPS_IS_ANNOTATION_MARKUP (self), NULL); - props = pps_annotation_markup_get_properties (markup); - return props->label; + return priv->label; } gboolean -pps_annotation_markup_set_label (PpsAnnotationMarkup *markup, +pps_annotation_markup_set_label (PpsAnnotationMarkup *self, const gchar *label) { - PpsAnnotationMarkupProps *props; + PpsAnnotationMarkupPrivate *priv = GET_ANNOT_MARKUP_PRIVATE (self); - g_return_val_if_fail (PPS_IS_ANNOTATION_MARKUP (markup), FALSE); + g_return_val_if_fail (PPS_IS_ANNOTATION_MARKUP (self), FALSE); g_return_val_if_fail (label != NULL, FALSE); - props = pps_annotation_markup_get_properties (markup); - if (g_strcmp0 (props->label, label) == 0) + if (g_strcmp0 (priv->label, label) == 0) return FALSE; - if (props->label) - g_free (props->label); - props->label = g_strdup (label); + g_free (priv->label); + priv->label = g_strdup (label); - g_object_notify (G_OBJECT (markup), "label"); + g_object_notify (G_OBJECT (self), "label"); return TRUE; } gdouble -pps_annotation_markup_get_opacity (PpsAnnotationMarkup *markup) +pps_annotation_markup_get_opacity (PpsAnnotationMarkup *self) { - PpsAnnotationMarkupProps *props; + PpsAnnotationMarkupPrivate *priv = GET_ANNOT_MARKUP_PRIVATE (self); - g_return_val_if_fail (PPS_IS_ANNOTATION_MARKUP (markup), 1.0); + g_return_val_if_fail (PPS_IS_ANNOTATION_MARKUP (self), 1.0); - props = pps_annotation_markup_get_properties (markup); - return props->opacity; + return priv->opacity; } gboolean -pps_annotation_markup_set_opacity (PpsAnnotationMarkup *markup, +pps_annotation_markup_set_opacity (PpsAnnotationMarkup *self, gdouble opacity) { - PpsAnnotationMarkupProps *props; + PpsAnnotationMarkupPrivate *priv = GET_ANNOT_MARKUP_PRIVATE (self); - g_return_val_if_fail (PPS_IS_ANNOTATION_MARKUP (markup), FALSE); + g_return_val_if_fail (PPS_IS_ANNOTATION_MARKUP (self), FALSE); - props = pps_annotation_markup_get_properties (markup); - if (props->opacity == opacity) + if (priv->opacity == opacity) return FALSE; - props->opacity = opacity; + priv->opacity = opacity; - g_object_notify (G_OBJECT (markup), "opacity"); + g_object_notify (G_OBJECT (self), "opacity"); return TRUE; } gboolean -pps_annotation_markup_can_have_popup (PpsAnnotationMarkup *markup) +pps_annotation_markup_can_have_popup (PpsAnnotationMarkup *self) { - PpsAnnotationMarkupProps *props; + PpsAnnotationMarkupPrivate *priv = GET_ANNOT_MARKUP_PRIVATE (self); - g_return_val_if_fail (PPS_IS_ANNOTATION_MARKUP (markup), FALSE); + g_return_val_if_fail (PPS_IS_ANNOTATION_MARKUP (self), FALSE); - props = pps_annotation_markup_get_properties (markup); - return props->can_have_popup; + return priv->can_have_popup; } gboolean -pps_annotation_markup_has_popup (PpsAnnotationMarkup *markup) +pps_annotation_markup_has_popup (PpsAnnotationMarkup *self) { - PpsAnnotationMarkupProps *props; + PpsAnnotationMarkupPrivate *priv = GET_ANNOT_MARKUP_PRIVATE (self); - g_return_val_if_fail (PPS_IS_ANNOTATION_MARKUP (markup), FALSE); + g_return_val_if_fail (PPS_IS_ANNOTATION_MARKUP (self), FALSE); - props = pps_annotation_markup_get_properties (markup); - return props->has_popup; + return priv->has_popup; } gboolean -pps_annotation_markup_set_has_popup (PpsAnnotationMarkup *markup, +pps_annotation_markup_set_has_popup (PpsAnnotationMarkup *self, gboolean has_popup) { - PpsAnnotationMarkupProps *props; + PpsAnnotationMarkupPrivate *priv = GET_ANNOT_MARKUP_PRIVATE (self); - g_return_val_if_fail (PPS_IS_ANNOTATION_MARKUP (markup), FALSE); + g_return_val_if_fail (PPS_IS_ANNOTATION_MARKUP (self), FALSE); - props = pps_annotation_markup_get_properties (markup); - if (props->has_popup == has_popup) + if (priv->has_popup == has_popup) return FALSE; - props->has_popup = has_popup; + priv->has_popup = has_popup; - g_object_notify (G_OBJECT (markup), "has-popup"); + g_object_notify (G_OBJECT (self), "has-popup"); return TRUE; } void -pps_annotation_markup_get_rectangle (PpsAnnotationMarkup *markup, +pps_annotation_markup_get_rectangle (PpsAnnotationMarkup *self, PpsRectangle *pps_rect) { - PpsAnnotationMarkupProps *props; + PpsAnnotationMarkupPrivate *priv = GET_ANNOT_MARKUP_PRIVATE (self); - g_return_if_fail (PPS_IS_ANNOTATION_MARKUP (markup)); + g_return_if_fail (PPS_IS_ANNOTATION_MARKUP (self)); g_return_if_fail (pps_rect != NULL); - props = pps_annotation_markup_get_properties (markup); - *pps_rect = props->rectangle; + *pps_rect = priv->rectangle; } gboolean -pps_annotation_markup_set_rectangle (PpsAnnotationMarkup *markup, +pps_annotation_markup_set_rectangle (PpsAnnotationMarkup *self, const PpsRectangle *pps_rect) { - PpsAnnotationMarkupProps *props; + PpsAnnotationMarkupPrivate *priv = GET_ANNOT_MARKUP_PRIVATE (self); - g_return_val_if_fail (PPS_IS_ANNOTATION_MARKUP (markup), FALSE); + g_return_val_if_fail (PPS_IS_ANNOTATION_MARKUP (self), FALSE); g_return_val_if_fail (pps_rect != NULL, FALSE); - props = pps_annotation_markup_get_properties (markup); - if (props->rectangle.x1 == pps_rect->x1 && - props->rectangle.y1 == pps_rect->y1 && - props->rectangle.x2 == pps_rect->x2 && - props->rectangle.y2 == pps_rect->y2) + if (priv->rectangle.x1 == pps_rect->x1 && + priv->rectangle.y1 == pps_rect->y1 && + priv->rectangle.x2 == pps_rect->x2 && + priv->rectangle.y2 == pps_rect->y2) return FALSE; - props->rectangle = *pps_rect; + priv->rectangle = *pps_rect; - g_object_notify (G_OBJECT (markup), "rectangle"); + g_object_notify (G_OBJECT (self), "rectangle"); return TRUE; } gboolean -pps_annotation_markup_get_popup_is_open (PpsAnnotationMarkup *markup) +pps_annotation_markup_get_popup_is_open (PpsAnnotationMarkup *self) { - PpsAnnotationMarkupProps *props; + PpsAnnotationMarkupPrivate *priv = GET_ANNOT_MARKUP_PRIVATE (self); - g_return_val_if_fail (PPS_IS_ANNOTATION_MARKUP (markup), FALSE); + g_return_val_if_fail (PPS_IS_ANNOTATION_MARKUP (self), FALSE); - props = pps_annotation_markup_get_properties (markup); - return props->popup_is_open; + return priv->popup_is_open; } gboolean -pps_annotation_markup_set_popup_is_open (PpsAnnotationMarkup *markup, +pps_annotation_markup_set_popup_is_open (PpsAnnotationMarkup *self, gboolean is_open) { - PpsAnnotationMarkupProps *props; + PpsAnnotationMarkupPrivate *priv = GET_ANNOT_MARKUP_PRIVATE (self); - g_return_val_if_fail (PPS_IS_ANNOTATION_MARKUP (markup), FALSE); + g_return_val_if_fail (PPS_IS_ANNOTATION_MARKUP (self), FALSE); - props = pps_annotation_markup_get_properties (markup); - if (props->popup_is_open == is_open) + if (priv->popup_is_open == is_open) return FALSE; - props->popup_is_open = is_open; + priv->popup_is_open = is_open; - g_object_notify (G_OBJECT (markup), "popup_is_open"); + g_object_notify (G_OBJECT (self), "popup_is_open"); return TRUE; } @@ -1201,11 +1147,6 @@ pps_annotation_text_set_property (GObject *object, { PpsAnnotationText *annot = PPS_ANNOTATION_TEXT (object); - if (prop_id < PROP_ATTACHMENT_ATTACHMENT) { - pps_annotation_markup_set_property (object, prop_id, value, pspec); - return; - } - switch (prop_id) { case PROP_TEXT_ICON: pps_annotation_text_set_icon (annot, g_value_get_enum (value)); @@ -1227,11 +1168,6 @@ pps_annotation_text_get_property (GObject *object, PpsAnnotationText *annot = PPS_ANNOTATION_TEXT (object); PpsAnnotationTextPrivate *priv = GET_ANNOT_TEXT_PRIVATE (annot); - if (prop_id < PROP_ATTACHMENT_ATTACHMENT) { - pps_annotation_markup_get_property (object, prop_id, value, pspec); - return; - } - switch (prop_id) { case PROP_TEXT_ICON: g_value_set_enum (value, priv->icon); @@ -1249,8 +1185,6 @@ pps_annotation_text_class_init (PpsAnnotationTextClass *klass) { GObjectClass *g_object_class = G_OBJECT_CLASS (klass); - pps_annotation_markup_class_install_properties (g_object_class); - g_object_class->set_property = pps_annotation_text_set_property; g_object_class->get_property = pps_annotation_text_get_property; @@ -1273,11 +1207,6 @@ pps_annotation_text_class_init (PpsAnnotationTextClass *klass) G_PARAM_STATIC_STRINGS)); } -static void -pps_annotation_text_markup_iface_init (PpsAnnotationMarkupInterface *iface) -{ -} - PpsAnnotation * pps_annotation_text_new (PpsPage *page) { @@ -1679,11 +1608,6 @@ pps_annotation_attachment_set_property (GObject *object, { PpsAnnotationAttachment *annot = PPS_ANNOTATION_ATTACHMENT (object); - if (prop_id < PROP_ATTACHMENT_ATTACHMENT) { - pps_annotation_markup_set_property (object, prop_id, value, pspec); - return; - } - switch (prop_id) { case PROP_ATTACHMENT_ATTACHMENT: pps_annotation_attachment_set_attachment (annot, g_value_get_object (value)); @@ -1702,11 +1626,6 @@ pps_annotation_attachment_get_property (GObject *object, PpsAnnotationAttachment *annot = PPS_ANNOTATION_ATTACHMENT (object); PpsAnnotationAttachmentPrivate *priv = GET_ANNOT_ATTACH_PRIVATE (annot); - if (prop_id < PROP_ATTACHMENT_ATTACHMENT) { - pps_annotation_markup_get_property (object, prop_id, value, pspec); - return; - } - switch (prop_id) { case PROP_ATTACHMENT_ATTACHMENT: g_value_set_object (value, priv->attachment); @@ -1721,8 +1640,6 @@ pps_annotation_attachment_class_init (PpsAnnotationAttachmentClass *klass) { GObjectClass *g_object_class = G_OBJECT_CLASS (klass); - pps_annotation_markup_class_install_properties (g_object_class); - g_object_class->set_property = pps_annotation_attachment_set_property; g_object_class->get_property = pps_annotation_attachment_get_property; g_object_class->finalize = pps_annotation_attachment_finalize; @@ -1738,11 +1655,6 @@ pps_annotation_attachment_class_init (PpsAnnotationAttachmentClass *klass) G_PARAM_STATIC_STRINGS)); } -static void -pps_annotation_attachment_markup_iface_init (PpsAnnotationMarkupInterface *iface) -{ -} - PpsAnnotation * pps_annotation_attachment_new (PpsPage *page, PpsAttachment *attachment) @@ -1797,11 +1709,6 @@ pps_annotation_text_markup_get_property (GObject *object, PpsAnnotationTextMarkup *annot = PPS_ANNOTATION_TEXT_MARKUP (object); PpsAnnotationTextMarkupPrivate *priv = GET_ANNOT_TEXT_MARKUP_PRIVATE (annot); - if (prop_id < PROP_TEXT_MARKUP_TYPE) { - pps_annotation_markup_get_property (object, prop_id, value, pspec); - return; - } - switch (prop_id) { case PROP_TEXT_MARKUP_TYPE: g_value_set_enum (value, priv->type); @@ -1820,11 +1727,6 @@ pps_annotation_text_markup_set_property (GObject *object, PpsAnnotationTextMarkup *annot = PPS_ANNOTATION_TEXT_MARKUP (object); PpsAnnotationTextMarkupPrivate *priv = GET_ANNOT_TEXT_MARKUP_PRIVATE (annot); - if (prop_id < PROP_TEXT_MARKUP_TYPE) { - pps_annotation_markup_set_property (object, prop_id, value, pspec); - return; - } - switch (prop_id) { case PROP_TEXT_MARKUP_TYPE: priv->type = g_value_get_enum (value); @@ -1847,8 +1749,6 @@ pps_annotation_text_markup_class_init (PpsAnnotationTextMarkupClass *class) { GObjectClass *g_object_class = G_OBJECT_CLASS (class); - pps_annotation_markup_class_install_properties (g_object_class); - g_object_class->get_property = pps_annotation_text_markup_get_property; g_object_class->set_property = pps_annotation_text_markup_set_property; @@ -1864,11 +1764,6 @@ pps_annotation_text_markup_class_init (PpsAnnotationTextMarkupClass *class) G_PARAM_STATIC_STRINGS)); } -static void -pps_annotation_text_markup_markup_iface_init (PpsAnnotationMarkupInterface *iface) -{ -} - PpsAnnotation * pps_annotation_text_markup_highlight_new (PpsPage *page) { diff --git a/libdocument/pps-annotation.h b/libdocument/pps-annotation.h index 604b72ba3..dc98a4f49 100644 --- a/libdocument/pps-annotation.h +++ b/libdocument/pps-annotation.h @@ -47,7 +47,11 @@ struct _PpsAnnotationClass { #define PPS_TYPE_ANNOTATION_MARKUP (pps_annotation_markup_get_type ()) PPS_PUBLIC -G_DECLARE_INTERFACE (PpsAnnotationMarkup, pps_annotation_markup, PPS, ANNOTATION_MARKUP, GObject); +G_DECLARE_DERIVABLE_TYPE (PpsAnnotationMarkup, pps_annotation_markup, PPS, ANNOTATION_MARKUP, PpsAnnotation); + +struct _PpsAnnotationMarkupClass { + PpsAnnotationClass parent_class; +}; /* PpsAnnotationText */ #define PPS_TYPE_ANNOTATION_TEXT (pps_annotation_text_get_type ()) -- GitLab From ba437c09dcdb8114a03e997fb42249c326bc9bb2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pablo=20Correa=20G=C3=B3mez?= Date: Fri, 27 Dec 2024 20:41:24 +0100 Subject: [PATCH 3/5] libdocument: make markup annots can-have-popup a read-only property The spec determines which markup annotations can have a popup. Instead of setting that definition in the backend, and set the property manually in different places, make each markup annotation type set its value at init time. --- libdocument/backend/pdf/pps-poppler.c | 27 ++------------------------- libdocument/pps-annotation.c | 13 +++++++------ libview/pps-view.c | 1 - 3 files changed, 9 insertions(+), 32 deletions(-) diff --git a/libdocument/backend/pdf/pps-poppler.c b/libdocument/backend/pdf/pps-poppler.c index 8c000e896..321da4b9b 100644 --- a/libdocument/backend/pdf/pps-poppler.c +++ b/libdocument/backend/pdf/pps-poppler.c @@ -2641,29 +2641,6 @@ get_poppler_annot_text_icon (PpsAnnotationTextIcon icon) } } -static gboolean -poppler_annot_can_have_popup_window (PopplerAnnot *poppler_annot) -{ - switch (poppler_annot_get_annot_type (poppler_annot)) { - case POPPLER_ANNOT_TEXT: - case POPPLER_ANNOT_LINE: - case POPPLER_ANNOT_SQUARE: - case POPPLER_ANNOT_CIRCLE: - case POPPLER_ANNOT_POLYGON: - case POPPLER_ANNOT_POLY_LINE: - case POPPLER_ANNOT_HIGHLIGHT: - case POPPLER_ANNOT_UNDERLINE: - case POPPLER_ANNOT_SQUIGGLY: - case POPPLER_ANNOT_STRIKE_OUT: - case POPPLER_ANNOT_CARET: - case POPPLER_ANNOT_INK: - case POPPLER_ANNOT_FILE_ATTACHMENT: - return TRUE; - default: - return FALSE; - } -} - static PpsAnnotation * pps_annot_from_poppler_annot (PopplerAnnot *poppler_annot, PpsPage *page) @@ -2859,7 +2836,8 @@ pps_annot_from_poppler_annot (PopplerAnnot *poppler_annot, pps_annotation_set_hidden (pps_annot, FALSE); } - if (poppler_annot_can_have_popup_window (poppler_annot)) { + if (PPS_IS_ANNOTATION_MARKUP (pps_annot) && + pps_annotation_markup_can_have_popup (PPS_ANNOTATION_MARKUP (pps_annot))) { PopplerAnnotMarkup *markup; gchar *label; gdouble opacity; @@ -2892,7 +2870,6 @@ pps_annot_from_poppler_annot (PopplerAnnot *poppler_annot, g_object_set (pps_annot, "opacity", opacity, - "can_have_popup", TRUE, NULL); g_free (label); diff --git a/libdocument/pps-annotation.c b/libdocument/pps-annotation.c index 6c10efea9..29ae404c1 100644 --- a/libdocument/pps-annotation.c +++ b/libdocument/pps-annotation.c @@ -844,7 +844,6 @@ pps_annotation_markup_set_property (GObject *object, GParamSpec *pspec) { PpsAnnotationMarkup *self = PPS_ANNOTATION_MARKUP (object); - PpsAnnotationMarkupPrivate *priv = GET_ANNOT_MARKUP_PRIVATE (self); switch (prop_id) { case PROP_MARKUP_LABEL: @@ -853,10 +852,6 @@ pps_annotation_markup_set_property (GObject *object, case PROP_MARKUP_OPACITY: pps_annotation_markup_set_opacity (self, g_value_get_double (value)); break; - case PROP_MARKUP_CAN_HAVE_POPUP: { - priv->can_have_popup = g_value_get_boolean (value); - break; - } case PROP_MARKUP_HAS_POPUP: pps_annotation_markup_set_has_popup (self, g_value_get_boolean (value)); break; @@ -942,7 +937,7 @@ pps_annotation_markup_class_init (PpsAnnotationMarkupClass *klass) "Whether it is allowed to have a popup " "window for this type of markup annotation", FALSE, - G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); + G_PARAM_READABLE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (g_object_class, PROP_MARKUP_HAS_POPUP, g_param_spec_boolean ("has-popup", @@ -1135,8 +1130,10 @@ static void pps_annotation_text_init (PpsAnnotationText *annot) { PpsAnnotationPrivate *priv = GET_ANNOT_PRIVATE (PPS_ANNOTATION (annot)); + PpsAnnotationMarkupPrivate *markup_priv = GET_ANNOT_MARKUP_PRIVATE (PPS_ANNOTATION_MARKUP (annot)); priv->type = PPS_ANNOTATION_TYPE_TEXT; + markup_priv->can_have_popup = TRUE; } static void @@ -1596,8 +1593,10 @@ static void pps_annotation_attachment_init (PpsAnnotationAttachment *annot) { PpsAnnotationPrivate *priv = GET_ANNOT_PRIVATE (PPS_ANNOTATION (annot)); + PpsAnnotationMarkupPrivate *markup_priv = GET_ANNOT_MARKUP_PRIVATE (PPS_ANNOTATION_MARKUP (annot)); priv->type = PPS_ANNOTATION_TYPE_ATTACHMENT; + markup_priv->can_have_popup = TRUE; } static void @@ -1740,8 +1739,10 @@ static void pps_annotation_text_markup_init (PpsAnnotationTextMarkup *annot) { PpsAnnotationPrivate *priv = GET_ANNOT_PRIVATE (PPS_ANNOTATION (annot)); + PpsAnnotationMarkupPrivate *markup_priv = GET_ANNOT_MARKUP_PRIVATE (PPS_ANNOTATION_MARKUP (annot)); priv->type = PPS_ANNOTATION_TYPE_TEXT_MARKUP; + markup_priv->can_have_popup = TRUE; } static void diff --git a/libview/pps-view.c b/libview/pps-view.c index adea7e476..3881e5533 100644 --- a/libview/pps-view.c +++ b/libview/pps-view.c @@ -3406,7 +3406,6 @@ pps_view_create_annotation_real (PpsView *view, popup_rect.y2 = popup_rect.y1 + ANNOT_POPUP_WINDOW_DEFAULT_HEIGHT; g_object_set (annot, "rectangle", &popup_rect, - "can-have-popup", TRUE, "has-popup", TRUE, "popup-is-open", FALSE, "label", g_get_real_name (), -- GitLab From 757297584ab4e8dd12b7afb93d08ec8ba3f52586 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pablo=20Correa=20G=C3=B3mez?= Date: Fri, 27 Dec 2024 20:47:10 +0100 Subject: [PATCH 4/5] libdocument: pdf: use more g_autofree macros --- libdocument/backend/pdf/pps-poppler.c | 20 +++++++------------- 1 file changed, 7 insertions(+), 13 deletions(-) diff --git a/libdocument/backend/pdf/pps-poppler.c b/libdocument/backend/pdf/pps-poppler.c index 321da4b9b..45092166f 100644 --- a/libdocument/backend/pdf/pps-poppler.c +++ b/libdocument/backend/pdf/pps-poppler.c @@ -2801,30 +2801,24 @@ pps_annot_from_poppler_annot (PopplerAnnot *poppler_annot, if (pps_annot) { time_t utime; - gchar *modified; - gchar *contents; - gchar *name; + g_autofree gchar *modified; + g_autofree gchar *contents; + g_autofree gchar *name; GdkRGBA color; contents = poppler_annot_get_contents (poppler_annot); - if (contents) { + if (contents) pps_annotation_set_contents (pps_annot, contents); - g_free (contents); - } name = poppler_annot_get_name (poppler_annot); - if (name) { + if (name) pps_annotation_set_name (pps_annot, name); - g_free (name); - } modified = poppler_annot_get_modified (poppler_annot); - if (poppler_date_parse (modified, &utime)) { + if (poppler_date_parse (modified, &utime)) pps_annotation_set_modified_from_time_t (pps_annot, utime); - } else { + else pps_annotation_set_modified (pps_annot, modified); - } - g_free (modified); poppler_annot_color_to_gdk_rgba (poppler_annot, &color); pps_annotation_set_rgba (pps_annot, &color); -- GitLab From f2f7ae9ff834136e644b41b1400b65f294665032 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pablo=20Correa=20G=C3=B3mez?= Date: Fri, 27 Dec 2024 20:53:30 +0100 Subject: [PATCH 5/5] libdocument: make stamp and free text annotations subclasses of markup These respect the specification, which says that they are both markup annotations, even if free-text annotations don't have a popup (and the contents are directly displayed) --- libdocument/pps-annotation.c | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/libdocument/pps-annotation.c b/libdocument/pps-annotation.c index 29ae404c1..2d7c749a2 100644 --- a/libdocument/pps-annotation.c +++ b/libdocument/pps-annotation.c @@ -85,7 +85,7 @@ struct _PpsAnnotationStamp { G_DEFINE_TYPE_WITH_CODE (PpsAnnotationStamp, pps_annotation_stamp, - PPS_TYPE_ANNOTATION, + PPS_TYPE_ANNOTATION_MARKUP, G_ADD_PRIVATE (PpsAnnotationStamp)); #define GET_ANNOT_STAMP_PRIVATE(o) pps_annotation_stamp_get_instance_private (o) @@ -101,7 +101,7 @@ struct _PpsAnnotationFreeText { G_DEFINE_TYPE_WITH_CODE (PpsAnnotationFreeText, pps_annotation_free_text, - PPS_TYPE_ANNOTATION, + PPS_TYPE_ANNOTATION_MARKUP, G_ADD_PRIVATE (PpsAnnotationFreeText)); #define GET_ANNOT_FREE_TEXT_PRIVATE(o) pps_annotation_free_text_get_instance_private (o) @@ -1273,8 +1273,10 @@ static void pps_annotation_stamp_init (PpsAnnotationStamp *annot) { PpsAnnotationPrivate *priv = GET_ANNOT_PRIVATE (PPS_ANNOTATION (annot)); + PpsAnnotationMarkupPrivate *markup_priv = GET_ANNOT_MARKUP_PRIVATE (PPS_ANNOTATION_MARKUP (annot)); priv->type = PPS_ANNOTATION_TYPE_STAMP; + markup_priv->can_have_popup = TRUE; } static void @@ -1348,8 +1350,10 @@ static void pps_annotation_free_text_init (PpsAnnotationFreeText *annot) { PpsAnnotationPrivate *priv = GET_ANNOT_PRIVATE (PPS_ANNOTATION (annot)); + PpsAnnotationMarkupPrivate *markup_priv = GET_ANNOT_MARKUP_PRIVATE (PPS_ANNOTATION_MARKUP (annot)); priv->type = PPS_ANNOTATION_TYPE_FREE_TEXT; + markup_priv->can_have_popup = FALSE; } static void -- GitLab