2 /* -*- Mode: C; c-basic-offset: 4 -*-
3 * vim: tabstop=4 shiftwidth=4 expandtab
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
20 #include "pygi-value.h"
21 #include "pygi-struct.h"
22 #include "pygi-python-compat.h"
23 #include "pygi-basictype.h"
24 #include "pygobject-object.h"
25 #include "pygi-type.h"
27 #include "pygpointer.h"
30 #include "pygparamspec.h"
34 _pygi_argument_from_g_value(const GValue
*value
,
35 GITypeInfo
*type_info
)
37 GIArgument arg
= { 0, };
39 GITypeTag type_tag
= g_type_info_get_tag (type_info
);
41 /* For the long handling: long can be equivalent to
42 int32 or int64, depending on the architecture, but
43 gi doesn't tell us (and same for ulong)
46 case GI_TYPE_TAG_BOOLEAN
:
47 arg
.v_boolean
= g_value_get_boolean (value
);
49 case GI_TYPE_TAG_INT8
:
50 arg
.v_int8
= g_value_get_schar (value
);
52 case GI_TYPE_TAG_INT16
:
53 case GI_TYPE_TAG_INT32
:
54 if (g_type_is_a (G_VALUE_TYPE (value
), G_TYPE_LONG
))
55 arg
.v_int32
= (gint32
)g_value_get_long (value
);
57 arg
.v_int32
= (gint32
)g_value_get_int (value
);
59 case GI_TYPE_TAG_INT64
:
60 if (g_type_is_a (G_VALUE_TYPE (value
), G_TYPE_LONG
))
61 arg
.v_int64
= g_value_get_long (value
);
63 arg
.v_int64
= g_value_get_int64 (value
);
65 case GI_TYPE_TAG_UINT8
:
66 arg
.v_uint8
= g_value_get_uchar (value
);
68 case GI_TYPE_TAG_UINT16
:
69 case GI_TYPE_TAG_UINT32
:
70 if (g_type_is_a (G_VALUE_TYPE (value
), G_TYPE_ULONG
))
71 arg
.v_uint32
= (guint32
)g_value_get_ulong (value
);
73 arg
.v_uint32
= (guint32
)g_value_get_uint (value
);
75 case GI_TYPE_TAG_UINT64
:
76 if (g_type_is_a (G_VALUE_TYPE (value
), G_TYPE_ULONG
))
77 arg
.v_uint64
= g_value_get_ulong (value
);
79 arg
.v_uint64
= g_value_get_uint64 (value
);
81 case GI_TYPE_TAG_UNICHAR
:
82 arg
.v_uint32
= g_value_get_schar (value
);
84 case GI_TYPE_TAG_FLOAT
:
85 arg
.v_float
= g_value_get_float (value
);
87 case GI_TYPE_TAG_DOUBLE
:
88 arg
.v_double
= g_value_get_double (value
);
90 case GI_TYPE_TAG_GTYPE
:
91 arg
.v_size
= g_value_get_gtype (value
);
93 case GI_TYPE_TAG_UTF8
:
94 case GI_TYPE_TAG_FILENAME
:
95 /* Callers are responsible for ensuring the GValue stays alive
96 * long enough for the string to be copied. */
97 arg
.v_string
= (char *)g_value_get_string (value
);
99 case GI_TYPE_TAG_GLIST
:
100 case GI_TYPE_TAG_GSLIST
:
101 case GI_TYPE_TAG_ARRAY
:
102 case GI_TYPE_TAG_GHASH
:
103 if (G_VALUE_HOLDS_BOXED (value
))
104 arg
.v_pointer
= g_value_get_boxed (value
);
106 /* e. g. GSettings::change-event */
107 arg
.v_pointer
= g_value_get_pointer (value
);
109 case GI_TYPE_TAG_INTERFACE
:
112 GIInfoType info_type
;
114 info
= g_type_info_get_interface (type_info
);
115 info_type
= g_base_info_get_type (info
);
117 g_base_info_unref (info
);
120 case GI_INFO_TYPE_FLAGS
:
121 arg
.v_uint
= g_value_get_flags (value
);
123 case GI_INFO_TYPE_ENUM
:
124 arg
.v_int
= g_value_get_enum (value
);
126 case GI_INFO_TYPE_INTERFACE
:
127 case GI_INFO_TYPE_OBJECT
:
128 if (G_VALUE_HOLDS_PARAM (value
))
129 arg
.v_pointer
= g_value_get_param (value
);
131 arg
.v_pointer
= g_value_get_object (value
);
133 case GI_INFO_TYPE_BOXED
:
134 case GI_INFO_TYPE_STRUCT
:
135 case GI_INFO_TYPE_UNION
:
136 if (G_VALUE_HOLDS (value
, G_TYPE_BOXED
)) {
137 arg
.v_pointer
= g_value_get_boxed (value
);
138 } else if (G_VALUE_HOLDS (value
, G_TYPE_VARIANT
)) {
139 arg
.v_pointer
= g_value_get_variant (value
);
140 } else if (G_VALUE_HOLDS (value
, G_TYPE_POINTER
)) {
141 arg
.v_pointer
= g_value_get_pointer (value
);
143 PyErr_Format (PyExc_NotImplementedError
,
144 "Converting GValue's of type '%s' is not implemented.",
145 g_type_name (G_VALUE_TYPE (value
)));
149 PyErr_Format (PyExc_NotImplementedError
,
150 "Converting GValue's of type '%s' is not implemented.",
151 g_info_type_to_string (info_type
));
156 case GI_TYPE_TAG_ERROR
:
157 arg
.v_pointer
= g_value_get_boxed (value
);
159 case GI_TYPE_TAG_VOID
:
160 arg
.v_pointer
= g_value_get_pointer (value
);
170 /* Ignore g_value_array deprecations. Although they are deprecated,
171 * we still need to support the marshaling of them in PyGObject.
173 G_GNUC_BEGIN_IGNORE_DEPRECATIONS
176 pyg_value_array_from_pyobject(GValue
*value
,
178 const GParamSpecValueArray
*pspec
)
181 GValueArray
*value_array
;
184 seq_len
= PySequence_Length(obj
);
189 len
= (guint
)seq_len
;
191 if (pspec
&& pspec
->fixed_n_elements
> 0 && len
!= pspec
->fixed_n_elements
)
194 value_array
= g_value_array_new(len
);
196 for (i
= 0; i
< len
; ++i
) {
197 PyObject
*item
= PySequence_GetItem(obj
, i
);
202 g_value_array_free(value_array
);
206 if (pspec
&& pspec
->element_spec
)
207 type
= G_PARAM_SPEC_VALUE_TYPE(pspec
->element_spec
);
208 else if (item
== Py_None
)
209 type
= G_TYPE_POINTER
; /* store None as NULL */
211 type
= pyg_type_from_object((PyObject
*)Py_TYPE(item
));
214 g_value_array_free(value_array
);
220 if (type
== G_TYPE_VALUE
) {
221 const GValue
* item_value
= pyg_boxed_get(item
, GValue
);
222 g_value_array_append(value_array
, item_value
);
224 GValue item_value
= { 0, };
227 g_value_init(&item_value
, type
);
228 status
= (pspec
&& pspec
->element_spec
)
229 ? pyg_param_gvalue_from_pyobject(&item_value
, item
, pspec
->element_spec
)
230 : pyg_value_from_pyobject(&item_value
, item
);
234 g_value_array_free(value_array
);
235 g_value_unset(&item_value
);
238 g_value_array_append(value_array
, &item_value
);
239 g_value_unset(&item_value
);
243 g_value_take_boxed(value
, value_array
);
247 G_GNUC_END_IGNORE_DEPRECATIONS
250 pyg_array_from_pyobject(GValue
*value
,
256 len
= PySequence_Length(obj
);
262 array
= g_array_new(FALSE
, TRUE
, sizeof(GValue
));
264 for (i
= 0; i
< len
; ++i
) {
265 PyObject
*item
= PySequence_GetItem(obj
, i
);
267 GValue item_value
= { 0, };
272 g_array_free(array
, FALSE
);
277 type
= G_TYPE_POINTER
; /* store None as NULL */
279 type
= pyg_type_from_object((PyObject
*)Py_TYPE(item
));
282 g_array_free(array
, FALSE
);
288 g_value_init(&item_value
, type
);
289 status
= pyg_value_from_pyobject(&item_value
, item
);
293 g_array_free(array
, FALSE
);
294 g_value_unset(&item_value
);
298 g_array_append_val(array
, item_value
);
301 g_value_take_boxed(value
, array
);
306 * pyg_value_from_pyobject_with_error:
307 * @value: the GValue object to store the converted value in.
308 * @obj: the Python object to convert.
310 * This function converts a Python object and stores the result in a
311 * GValue. The GValue must be initialised in advance with
312 * g_value_init(). If the Python object can't be converted to the
313 * type of the GValue, then an error is returned.
315 * Returns: 0 on success, -1 on error.
318 pyg_value_from_pyobject_with_error(GValue
*value
, PyObject
*obj
)
320 GType value_type
= G_VALUE_TYPE(value
);
322 switch (G_TYPE_FUNDAMENTAL(value_type
)) {
323 case G_TYPE_INTERFACE
:
324 /* we only handle interface types that have a GObject prereq */
325 if (g_type_is_a(value_type
, G_TYPE_OBJECT
)) {
327 g_value_set_object(value
, NULL
);
329 if (!PyObject_TypeCheck(obj
, &PyGObject_Type
)) {
330 PyErr_SetString(PyExc_TypeError
, "GObject is required");
333 if (!G_TYPE_CHECK_INSTANCE_TYPE(pygobject_get(obj
),
335 PyErr_SetString(PyExc_TypeError
, "Invalid GObject type for assignment");
338 g_value_set_object(value
, pygobject_get(obj
));
341 PyErr_SetString(PyExc_TypeError
, "Unsupported conversion");
348 if (pygi_gschar_from_py (obj
, &temp
)) {
349 g_value_set_schar (value
, temp
);
357 if (pygi_guchar_from_py (obj
, &temp
)) {
358 g_value_set_uchar (value
, temp
);
366 if (pygi_gboolean_from_py (obj
, &temp
)) {
367 g_value_set_boolean (value
, temp
);
375 if (pygi_gint_from_py (obj
, &temp
)) {
376 g_value_set_int (value
, temp
);
384 if (pygi_guint_from_py (obj
, &temp
)) {
385 g_value_set_uint (value
, temp
);
393 if (pygi_glong_from_py (obj
, &temp
)) {
394 g_value_set_long (value
, temp
);
402 if (pygi_gulong_from_py (obj
, &temp
)) {
403 g_value_set_ulong (value
, temp
);
411 if (pygi_gint64_from_py (obj
, &temp
)) {
412 g_value_set_int64 (value
, temp
);
420 if (pygi_guint64_from_py (obj
, &temp
)) {
421 g_value_set_uint64 (value
, temp
);
429 if (pyg_enum_get_value(G_VALUE_TYPE(value
), obj
, &val
) < 0) {
432 g_value_set_enum(value
, val
);
438 if (pyg_flags_get_value(G_VALUE_TYPE(value
), obj
, &val
) < 0) {
441 g_value_set_flags(value
, val
);
448 if (pygi_gfloat_from_py (obj
, &temp
)) {
449 g_value_set_float (value
, temp
);
457 if (pygi_gdouble_from_py (obj
, &temp
)) {
458 g_value_set_double (value
, temp
);
466 if (pygi_utf8_from_py (obj
, &temp
)) {
467 g_value_take_string (value
, temp
);
470 /* also allows setting anything implementing __str__ */
473 str
= PyObject_Str (obj
);
476 if (pygi_utf8_from_py (str
, &temp
)) {
478 g_value_take_string (value
, temp
);
487 g_value_set_pointer(value
, NULL
);
488 else if (PyObject_TypeCheck(obj
, &PyGPointer_Type
) &&
489 G_VALUE_HOLDS(value
, ((PyGPointer
*)obj
)->gtype
))
490 g_value_set_pointer(value
, pyg_pointer_get(obj
, gpointer
));
491 else if (PyCapsule_CheckExact (obj
))
492 g_value_set_pointer(value
, PyCapsule_GetPointer (obj
, NULL
));
493 else if (G_VALUE_HOLDS_GTYPE (value
))
494 g_value_set_gtype (value
, pyg_type_from_object (obj
));
496 PyErr_SetString(PyExc_TypeError
, "Expected pointer");
502 gboolean holds_value_array
;
504 G_GNUC_BEGIN_IGNORE_DEPRECATIONS
505 holds_value_array
= G_VALUE_HOLDS(value
, G_TYPE_VALUE_ARRAY
);
506 G_GNUC_END_IGNORE_DEPRECATIONS
509 g_value_set_boxed(value
, NULL
);
510 else if (G_VALUE_HOLDS(value
, PY_TYPE_OBJECT
))
511 g_value_set_boxed(value
, obj
);
512 else if (PyObject_TypeCheck(obj
, &PyGBoxed_Type
) &&
513 G_VALUE_HOLDS(value
, ((PyGBoxed
*)obj
)->gtype
))
514 g_value_set_boxed(value
, pyg_boxed_get(obj
, gpointer
));
515 else if (G_VALUE_HOLDS(value
, G_TYPE_VALUE
)) {
519 type
= pyg_type_from_object((PyObject
*)Py_TYPE(obj
));
520 if (G_UNLIKELY (! type
)) {
523 n_value
= g_new0 (GValue
, 1);
524 g_value_init (n_value
, type
);
525 g_value_take_boxed (value
, n_value
);
526 return pyg_value_from_pyobject_with_error (n_value
, obj
);
528 else if (PySequence_Check(obj
) && holds_value_array
)
529 return pyg_value_array_from_pyobject(value
, obj
, NULL
);
531 else if (PySequence_Check(obj
) &&
532 G_VALUE_HOLDS(value
, G_TYPE_ARRAY
))
533 return pyg_array_from_pyobject(value
, obj
);
534 else if (PYGLIB_PyUnicode_Check(obj
) &&
535 G_VALUE_HOLDS(value
, G_TYPE_GSTRING
)) {
539 if (PYGLIB_PyUnicode_AsStringAndSize(obj
, &buffer
, &len
))
541 string
= g_string_new_len(buffer
, len
);
542 g_value_set_boxed(value
, string
);
543 g_string_free (string
, TRUE
);
546 else if ((bm
= pyg_type_lookup(G_VALUE_TYPE(value
))) != NULL
)
547 return bm
->tovalue(value
, obj
);
548 else if (PyCapsule_CheckExact (obj
))
549 g_value_set_boxed(value
, PyCapsule_GetPointer (obj
, NULL
));
551 PyErr_SetString(PyExc_TypeError
, "Expected Boxed");
557 /* we need to support both the wrapped _gi.GParamSpec and the GI
558 * GObject.ParamSpec */
559 if (G_IS_PARAM_SPEC (pygobject_get (obj
)))
560 g_value_set_param(value
, G_PARAM_SPEC (pygobject_get (obj
)));
561 else if (pyg_param_spec_check (obj
))
562 g_value_set_param(value
, PyCapsule_GetPointer (obj
, NULL
));
564 PyErr_SetString(PyExc_TypeError
, "Expected ParamSpec");
569 if (obj
== Py_None
) {
570 g_value_set_object(value
, NULL
);
571 } else if (PyObject_TypeCheck(obj
, &PyGObject_Type
) &&
572 G_TYPE_CHECK_INSTANCE_TYPE(pygobject_get(obj
),
573 G_VALUE_TYPE(value
))) {
574 g_value_set_object(value
, pygobject_get(obj
));
576 PyErr_SetString(PyExc_TypeError
, "Expected GObject");
583 g_value_set_variant(value
, NULL
);
584 else if (pyg_type_from_object_strict(obj
, FALSE
) == G_TYPE_VARIANT
)
585 g_value_set_variant(value
, pyg_boxed_get(obj
, GVariant
));
587 PyErr_SetString(PyExc_TypeError
, "Expected Variant");
595 if ((bm
= pyg_type_lookup(G_VALUE_TYPE(value
))) != NULL
) {
596 return bm
->tovalue(value
, obj
);
598 PyErr_SetString(PyExc_TypeError
, "Unknown value type");
605 /* If an error occurred, unset the GValue but don't clear the Python error. */
606 if (PyErr_Occurred()) {
607 g_value_unset(value
);
615 * pyg_value_from_pyobject:
616 * @value: the GValue object to store the converted value in.
617 * @obj: the Python object to convert.
619 * Same basic function as pyg_value_from_pyobject_with_error but clears
620 * any Python errors before returning.
622 * Returns: 0 on success, -1 on error.
625 pyg_value_from_pyobject(GValue
*value
, PyObject
*obj
)
627 int res
= pyg_value_from_pyobject_with_error (value
, obj
);
629 if (PyErr_Occurred()) {
637 * pygi_value_to_py_basic_type:
638 * @value: the GValue object.
639 * @handled: (out): TRUE if the return value is defined
641 * This function creates/returns a Python wrapper object that
642 * represents the GValue passed as an argument limited to supporting basic types
643 * like ints, bools, and strings.
645 * Returns: a PyObject representing the value.
648 pygi_value_to_py_basic_type (const GValue
*value
, GType fundamental
, gboolean
*handled
)
651 switch (fundamental
) {
653 return PYGLIB_PyLong_FromLong (g_value_get_schar (value
));
655 return PYGLIB_PyLong_FromLong (g_value_get_uchar (value
));
657 return pygi_gboolean_to_py (g_value_get_boolean (value
));
659 return pygi_gint_to_py (g_value_get_int (value
));
661 return pygi_guint_to_py (g_value_get_uint (value
));
663 return pygi_glong_to_py (g_value_get_long(value
));
665 return pygi_gulong_to_py (g_value_get_ulong (value
));
667 return pygi_gint64_to_py (g_value_get_int64 (value
));
669 return pygi_guint64_to_py (g_value_get_uint64 (value
));
671 return pyg_enum_from_gtype (G_VALUE_TYPE (value
),
672 g_value_get_enum (value
));
674 return pyg_flags_from_gtype (G_VALUE_TYPE (value
),
675 g_value_get_flags (value
));
677 return pygi_gfloat_to_py (g_value_get_float (value
));
679 return pygi_gdouble_to_py (g_value_get_double (value
));
681 return pygi_utf8_to_py (g_value_get_string (value
));
689 * value_to_py_structured_type:
690 * @value: the GValue object.
691 * @copy_boxed: true if boxed values should be copied.
693 * This function creates/returns a Python wrapper object that
694 * represents the GValue passed as an argument.
696 * Returns: a PyObject representing the value or NULL and sets an error;
699 value_to_py_structured_type (const GValue
*value
, GType fundamental
, gboolean copy_boxed
)
701 const gchar
*type_name
;
703 switch (fundamental
) {
704 case G_TYPE_INTERFACE
:
705 if (g_type_is_a(G_VALUE_TYPE(value
), G_TYPE_OBJECT
))
706 return pygobject_new(g_value_get_object(value
));
711 if (G_VALUE_HOLDS_GTYPE (value
))
712 return pyg_type_wrapper_new (g_value_get_gtype (value
));
714 return pyg_pointer_new(G_VALUE_TYPE(value
),
715 g_value_get_pointer(value
));
718 gboolean holds_value_array
;
720 G_GNUC_BEGIN_IGNORE_DEPRECATIONS
721 holds_value_array
= G_VALUE_HOLDS(value
, G_TYPE_VALUE_ARRAY
);
722 G_GNUC_END_IGNORE_DEPRECATIONS
724 if (G_VALUE_HOLDS(value
, PY_TYPE_OBJECT
)) {
725 PyObject
*ret
= (PyObject
*)g_value_dup_boxed(value
);
731 } else if (G_VALUE_HOLDS(value
, G_TYPE_VALUE
)) {
732 GValue
*n_value
= g_value_get_boxed (value
);
733 return pyg_value_as_pyobject(n_value
, copy_boxed
);
734 } else if (holds_value_array
) {
735 GValueArray
*array
= (GValueArray
*) g_value_get_boxed(value
);
736 Py_ssize_t n_values
= array
? array
->n_values
: 0;
737 PyObject
*ret
= PyList_New(n_values
);
739 for (i
= 0; i
< n_values
; ++i
)
740 PyList_SET_ITEM(ret
, i
, pyg_value_as_pyobject
741 (array
->values
+ i
, copy_boxed
));
743 } else if (G_VALUE_HOLDS(value
, G_TYPE_GSTRING
)) {
744 GString
*string
= (GString
*) g_value_get_boxed(value
);
745 PyObject
*ret
= PYGLIB_PyUnicode_FromStringAndSize(string
->str
, string
->len
);
748 bm
= pyg_type_lookup(G_VALUE_TYPE(value
));
750 return bm
->fromvalue(value
);
753 return pygi_gboxed_new(G_VALUE_TYPE(value
),
754 g_value_get_boxed(value
), TRUE
, TRUE
);
756 return pygi_gboxed_new(G_VALUE_TYPE(value
),
757 g_value_get_boxed(value
),FALSE
,FALSE
);
761 return pyg_param_spec_new(g_value_get_param(value
));
763 return pygobject_new(g_value_get_object(value
));
766 GVariant
*v
= g_value_get_variant(value
);
771 return pygi_struct_new_from_g_type (G_TYPE_VARIANT
, g_variant_ref(v
), FALSE
);
776 if ((bm
= pyg_type_lookup(G_VALUE_TYPE(value
))))
777 return bm
->fromvalue(value
);
782 type_name
= g_type_name (G_VALUE_TYPE (value
));
783 if (type_name
== NULL
) {
784 type_name
= "(null)";
786 PyErr_Format (PyExc_TypeError
, "unknown type %s", type_name
);
792 * pyg_value_as_pyobject:
793 * @value: the GValue object.
794 * @copy_boxed: true if boxed values should be copied.
796 * This function creates/returns a Python wrapper object that
797 * represents the GValue passed as an argument.
799 * Returns: a PyObject representing the value or %NULL and sets an exception.
802 pyg_value_as_pyobject (const GValue
*value
, gboolean copy_boxed
)
806 GType fundamental
= G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (value
));
808 /* HACK: special case char and uchar to return PyBytes intstead of integers
809 * in the general case. Property access will skip this by calling
810 * pygi_value_to_py_basic_type() directly.
811 * See: https://bugzilla.gnome.org/show_bug.cgi?id=733893 */
812 if (fundamental
== G_TYPE_CHAR
) {
813 gint8 val
= g_value_get_schar(value
);
814 return PYGLIB_PyUnicode_FromStringAndSize ((char *)&val
, 1);
815 } else if (fundamental
== G_TYPE_UCHAR
) {
816 guint8 val
= g_value_get_uchar(value
);
817 return PYGLIB_PyBytes_FromStringAndSize ((char *)&val
, 1);
820 pyobj
= pygi_value_to_py_basic_type (value
, fundamental
, &handled
);
824 pyobj
= value_to_py_structured_type (value
, fundamental
, copy_boxed
);
830 pyg_param_gvalue_from_pyobject(GValue
* value
,
832 const GParamSpec
* pspec
)
834 if (G_IS_PARAM_SPEC_UNICHAR(pspec
)) {
837 if (!pyg_pyobj_to_unichar_conv(py_obj
, &u
)) {
841 g_value_set_uint(value
, u
);
844 else if (G_IS_PARAM_SPEC_VALUE_ARRAY(pspec
))
845 return pyg_value_array_from_pyobject(value
, py_obj
,
846 G_PARAM_SPEC_VALUE_ARRAY(pspec
));
848 return pyg_value_from_pyobject(value
, py_obj
);
853 pyg_param_gvalue_as_pyobject(const GValue
* gvalue
,
855 const GParamSpec
* pspec
)
857 if (G_IS_PARAM_SPEC_UNICHAR(pspec
)) {
862 u
= g_value_get_uint (gvalue
);
863 encoded
= g_ucs4_to_utf8 (&u
, 1, NULL
, NULL
, NULL
);
864 if (encoded
== NULL
) {
865 PyErr_SetString (PyExc_ValueError
, "Failed to decode");
868 retval
= PyUnicode_FromString (encoded
);
873 return pyg_value_as_pyobject(gvalue
, copy_boxed
);
878 pyg__gvalue_get(PyObject
*module
, PyObject
*pygvalue
)
880 if (!pyg_boxed_check (pygvalue
, G_TYPE_VALUE
)) {
881 PyErr_SetString (PyExc_TypeError
, "Expected GValue argument.");
885 return pyg_value_as_pyobject (pyg_boxed_get(pygvalue
, GValue
),
886 /*copy_boxed=*/ TRUE
);
890 pyg__gvalue_set(PyObject
*module
, PyObject
*args
)
895 if (!PyArg_ParseTuple (args
, "OO:_gi._gvalue_set",
896 &pygvalue
, &pyobject
))
899 if (!pyg_boxed_check (pygvalue
, G_TYPE_VALUE
)) {
900 PyErr_SetString (PyExc_TypeError
, "Expected GValue argument.");
904 if (pyg_value_from_pyobject_with_error (pyg_boxed_get (pygvalue
, GValue
),