1 /* Fo
2  * fo-property-border-after-precedence.c: 'border-after-precedence' property
3  *
4  * Copyright (C) 2001 Sun Microsystems
5  * Copyright (C) 2007 Menteith Consulting Ltd
6  *
7  * See COPYING for the status of this software.
8  */
9 
10 #include <string.h>
11 #include "fo-utils.h"
12 #include "fo-context.h"
13 #include "datatype/fo-datatype.h"
14 #include "property/fo-property-private.h"
15 #include "property/fo-property-font-size.h"
16 #include "property/fo-property-border-after-precedence.h"
17 #include "property/fo-property-util.h"
18 
19 /* border-after-precedence */
20 /* Inherited: FALSE */
21 /* Shorthand: FALSE */
22 /* force | <integer> | inherit */
23 /* Initial value: fo:table: 6, fo:table-cell: 5, fo:table-column: 4, fo:table-row: 3, fo:table-body: 2, fo:table-header: 1, fo:table-footer: 0 */
24 
25 struct _FoPropertyBorderAfterPrecedence
26 {
27   FoProperty parent_instance;
28 };
29 
30 struct _FoPropertyBorderAfterPrecedenceClass
31 {
32   FoPropertyClass parent_class;
33 };
34 
35 static void fo_property_border_after_precedence_init         (FoPropertyBorderAfterPrecedence      *property_border_after_precedence);
36 static void fo_property_border_after_precedence_class_init   (FoPropertyBorderAfterPrecedenceClass *klass);
37 static void fo_property_border_after_precedence_finalize     (GObject       *object);
38 
39 static FoDatatype* fo_property_border_after_precedence_validate (FoDatatype *datatype,
40                                                                  FoContext  *context,
41                                                                  GError    **error);
42 
43 static const gchar class_name[] = "border-after-precedence";
44 static gpointer parent_class;
45 
46 /**
47  * fo_property_border_after_precedence_get_type:
48  *
49  * Register the #FoPropertyBorderAfterPrecedence type if not already registered and
50  * return its #GType value.
51  *
52  * Return value: #GType of #FoPropertyBorderAfterPrecedence.
53  **/
54 GType
fo_property_border_after_precedence_get_type(void)55 fo_property_border_after_precedence_get_type (void)
56 {
57   static GType object_type = 0;
58 
59   if (!object_type)
60     {
61       static const GTypeInfo object_info =
62       {
63         sizeof (FoPropertyBorderAfterPrecedenceClass),
64         NULL,           /* base_init */
65         NULL,           /* base_finalize */
66         (GClassInitFunc) fo_property_border_after_precedence_class_init,
67         NULL,           /* class_finalize */
68         NULL,           /* class_data */
69         sizeof (FoPropertyBorderAfterPrecedence),
70         0,              /* n_preallocs */
71         (GInstanceInitFunc) fo_property_border_after_precedence_init,
72 	NULL		/* value_table */
73       };
74 
75       object_type = g_type_register_static (FO_TYPE_PROPERTY,
76                                             class_name,
77                                             &object_info, 0);
78     }
79 
80   return object_type;
81 }
82 
83 /**
84  * fo_property_border_after_precedence_init:
85  * @border_after_precedence: #FoPropertyBorderAfterPrecedence object to initialise.
86  *
87  * Implements #GInstanceInitFunc for #FoPropertyBorderAfterPrecedence.
88  **/
89 void
fo_property_border_after_precedence_init(FoPropertyBorderAfterPrecedence * border_after_precedence)90 fo_property_border_after_precedence_init (FoPropertyBorderAfterPrecedence *border_after_precedence)
91 {
92   FO_PROPERTY (border_after_precedence)->value =
93     NULL;
94 }
95 
96 /**
97  * fo_property_border_after_precedence_class_init:
98  * @klass: #FoPropertyBorderAfterPrecedenceClass object to initialise.
99  *
100  * Implements #GClassInitFunc for #FoPropertyBorderAfterPrecedenceClass.
101  **/
102 void
fo_property_border_after_precedence_class_init(FoPropertyBorderAfterPrecedenceClass * klass)103 fo_property_border_after_precedence_class_init (FoPropertyBorderAfterPrecedenceClass *klass)
104 {
105   GObjectClass *object_class = G_OBJECT_CLASS (klass);
106   FoPropertyClass *property_class = FO_PROPERTY_CLASS (klass);
107 
108   parent_class = g_type_class_peek_parent (klass);
109 
110   object_class->finalize = fo_property_border_after_precedence_finalize;
111 
112   property_class->is_inherited = FALSE;
113   property_class->is_shorthand = FALSE;
114   property_class->resolve_enum =
115     fo_property_util_resolve_force_enum;
116   property_class->validate =
117     fo_property_border_after_precedence_validate;
118   property_class->get_initial =
119     fo_property_border_after_precedence_get_initial;
120 }
121 
122 /**
123  * fo_property_border_after_precedence_finalize:
124  * @object: #FoPropertyBorderAfterPrecedence object to finalize.
125  *
126  * Implements #GObjectFinalizeFunc for #FoPropertyBorderAfterPrecedence.
127  **/
128 void
fo_property_border_after_precedence_finalize(GObject * object)129 fo_property_border_after_precedence_finalize (GObject *object)
130 {
131   FoPropertyBorderAfterPrecedence *border_after_precedence;
132 
133   border_after_precedence = FO_PROPERTY_BORDER_AFTER_PRECEDENCE (object);
134 
135   G_OBJECT_CLASS (parent_class)->finalize (object);
136 }
137 
138 
139 /**
140  * fo_property_border_after_precedence_new:
141  *
142  * Creates a new #FoPropertyBorderAfterPrecedence initialized to default value.
143  *
144  * Return value: the new #FoPropertyBorderAfterPrecedence.
145  **/
146 FoProperty*
fo_property_border_after_precedence_new(void)147 fo_property_border_after_precedence_new (void)
148 {
149   FoProperty* border_after_precedence;
150 
151   border_after_precedence =
152     FO_PROPERTY (g_object_new (fo_property_border_after_precedence_get_type (),
153                                NULL));
154 
155   return border_after_precedence;
156 }
157 
158 /**
159  * fo_property_border_after_precedence_validate:
160  * @datatype: #FoDatatype to be validated against allowed datatypes and
161  *            values for current property.
162  * @context:  #FoContext object from which to possibly inherit values.
163  * @error:    Information about any error that has occurred.
164  *
165  * Validates @datatype against allowed values.  Returns @datatype, a
166  * replacement datatype value, or NULL if validation failed.
167  *
168  * Return value: Valid datatype value or NULL.
169  **/
170 FoDatatype*
fo_property_border_after_precedence_validate(FoDatatype * datatype,FoContext * context,GError ** error)171 fo_property_border_after_precedence_validate (FoDatatype *datatype,
172                                               FoContext  *context,
173                                               GError    **error)
174 {
175   FoDatatype *new_datatype;
176   GError     *tmp_error = NULL;
177   gchar      *token;
178 
179   g_return_val_if_fail (datatype != NULL, NULL);
180   g_return_val_if_fail (FO_IS_DATATYPE (datatype), NULL);
181   g_return_val_if_fail (context != NULL, NULL);
182   g_return_val_if_fail (FO_IS_CONTEXT (context), NULL);
183   g_return_val_if_fail (error == NULL || *error == NULL, NULL);
184 
185   if (FO_IS_ENUM (datatype))
186     {
187       FoEnumEnum value = fo_enum_get_value (datatype);
188 
189       if ((value == FO_ENUM_ENUM_FORCE))
190 	{
191 	  return datatype;
192 	}
193       else
194 	{
195 	  gchar *datatype_sprintf = fo_object_sprintf (datatype);
196 
197 	  g_set_error (error,
198 		       FO_FO_ERROR,
199 		       FO_FO_ERROR_ENUMERATION_TOKEN,
200 		       _(fo_fo_error_messages[FO_FO_ERROR_ENUMERATION_TOKEN]),
201 		       class_name,
202 		       datatype_sprintf,
203 		       g_type_name (G_TYPE_FROM_INSTANCE (datatype)));
204 
205 	  g_object_unref (datatype);
206 
207 	  g_free (datatype_sprintf);
208 
209 	  return NULL;
210 	}
211     }
212   else if (FO_IS_STRING (datatype))
213     {
214       token = fo_string_get_value (datatype);
215 
216       new_datatype =
217         fo_property_util_resolve_force_enum (token, context, &tmp_error);
218 
219       g_object_unref (datatype);
220 
221       fo_propagate_and_return_val_if_error (error, tmp_error, NULL);
222 
223       return new_datatype;
224     }
225   else if (FO_IS_NAME (datatype))
226     {
227       token = fo_name_get_value (datatype);
228 
229       new_datatype =
230         fo_property_util_resolve_force_enum (token, context, &tmp_error);
231 
232       g_object_unref (datatype);
233 
234       fo_propagate_and_return_val_if_error (error, tmp_error, NULL);
235 
236       return new_datatype;
237     }
238   else if (FO_IS_INTEGER (datatype))
239     {
240       return datatype;
241     }
242   else if (FO_IS_NUMBER (datatype))
243     {
244       new_datatype =
245         fo_integer_new_with_value ((gint) fo_number_get_value (datatype));
246 
247       g_object_unref (datatype);
248 
249       return new_datatype;
250     }
251   else
252     {
253       gchar *datatype_sprintf = fo_object_sprintf (datatype);
254 
255       g_set_error (error,
256 		   FO_FO_ERROR,
257 		   FO_FO_ERROR_DATATYPE,
258 		   _(fo_fo_error_messages[FO_FO_ERROR_DATATYPE]),
259 		   class_name,
260 		   datatype_sprintf,
261 		   g_type_name (G_TYPE_FROM_INSTANCE (datatype)));
262 
263       g_object_unref (datatype);
264 
265       g_free (datatype_sprintf);
266 
267       return NULL;
268     }
269 }
270 
271 /**
272  * fo_property_border_after_precedence_get_initial:
273  *
274  * Get an instance of the property with the correct initial value.
275  *
276  * Return value: An instance of the property.
277  **/
278 FoProperty*
fo_property_border_after_precedence_get_initial(void)279 fo_property_border_after_precedence_get_initial (void)
280 {
281   static FoProperty *border_after_precedence = NULL;
282 
283   if (border_after_precedence == NULL)
284     {
285       border_after_precedence =
286 	fo_property_border_after_precedence_new ();
287     }
288 
289   return border_after_precedence;
290 }
291