source: appstream-generator/build/girepo/gobject/Value.d @ 4841

Last change on this file since 4841 was 4841, checked in by Juanma, 2 years ago

Initial release

File size: 45.2 KB
Line 
1/*
2 * Licensed under the GNU Lesser General Public License Version 3
3 *
4 * This library is free software: you can redistribute it and/or modify
5 * it under the terms of the GNU Lesser General Public License as published by
6 * the Free Software Foundation, either version 3 of the license, or
7 * (at your option) any later version.
8 *
9 * This software is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 * GNU Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public License
15 * along with this library.  If not, see <http://www.gnu.org/licenses/>.
16 */
17
18// generated automatically - do not change
19
20
21module gobject.Value;
22
23private import gi.gobject;
24public  import gi.gobjecttypes;
25private import glib.Str;
26private import glib.Variant;
27private import glib.VariantType;
28private import gobject.ObjectG;
29private import gobject.ParamSpec;
30
31
32/**
33 * An opaque structure used to hold different types of values.
34 * The data within the structure has protected scope: it is accessible only
35 * to functions within a #GTypeValueTable structure, or implementations of
36 * the g_value_*() API. That is, code portions which implement new fundamental
37 * types.
38 * #GValue users cannot make any assumptions about how data is stored
39 * within the 2 element @data union, and the @g_type member should
40 * only be accessed through the G_VALUE_TYPE() macro.
41 */
42public class Value
43{
44        /** the main Gtk struct */
45        protected GValue* gValue;
46        protected bool ownedRef;
47
48        /** Get the main Gtk struct */
49        public GValue* getValueStruct()
50        {
51                return gValue;
52        }
53
54        /** the main Gtk struct as a void* */
55        protected void* getStruct()
56        {
57                return cast(void*)gValue;
58        }
59
60        /**
61         * Sets our main struct and passes it to the parent class.
62         */
63        public this (GValue* gValue, bool ownedRef = false)
64        {
65                this.gValue = gValue;
66                this.ownedRef = ownedRef;
67        }
68
69        /** */
70        public this()
71        {
72                this(new GValue);
73        }
74       
75        /** */
76        this(string value)
77        {
78                this();
79                init(GType.STRING);
80                setString(value);
81        }
82       
83        /** */
84        this(int value)
85        {
86                this();
87                init(GType.INT);
88                setInt(value);
89        }
90       
91        /** */
92        this(float value)
93        {
94                this();
95                init(GType.FLOAT);
96                setFloat(value);
97        }
98       
99        /** */
100        this(double value)
101        {
102                this();
103                init(GType.DOUBLE);
104                setDouble(value);
105        }
106
107        /**
108         */
109
110        /** */
111        public static GType getType()
112        {
113                return g_value_get_type();
114        }
115
116        /**
117         * Copies the value of @src_value into @dest_value.
118         *
119         * Params:
120         *     destValue = An initialized #GValue structure of the same type as @src_value.
121         */
122        public void copy(Value destValue)
123        {
124                g_value_copy(gValue, (destValue is null) ? null : destValue.getValueStruct());
125        }
126
127        /**
128         * Get the contents of a %G_TYPE_BOXED derived #GValue.  Upon getting,
129         * the boxed value is duplicated and needs to be later freed with
130         * g_boxed_free(), e.g. like: g_boxed_free (G_VALUE_TYPE (@value),
131         * return_value);
132         *
133         * Returns: boxed contents of @value
134         */
135        public void* dupBoxed()
136        {
137                return g_value_dup_boxed(gValue);
138        }
139
140        /**
141         * Get the contents of a %G_TYPE_OBJECT derived #GValue, increasing
142         * its reference count. If the contents of the #GValue are %NULL, then
143         * %NULL will be returned.
144         *
145         * Returns: object content of @value,
146         *     should be unreferenced when no longer needed.
147         */
148        public ObjectG dupObject()
149        {
150                auto p = g_value_dup_object(gValue);
151               
152                if(p is null)
153                {
154                        return null;
155                }
156               
157                return ObjectG.getDObject!(ObjectG)(cast(GObject*) p, true);
158        }
159
160        /**
161         * Get the contents of a %G_TYPE_PARAM #GValue, increasing its
162         * reference count.
163         *
164         * Returns: #GParamSpec content of @value, should be unreferenced when
165         *     no longer needed.
166         */
167        public ParamSpec dupParam()
168        {
169                auto p = g_value_dup_param(gValue);
170               
171                if(p is null)
172                {
173                        return null;
174                }
175               
176                return ObjectG.getDObject!(ParamSpec)(cast(GParamSpec*) p);
177        }
178
179        /**
180         * Get a copy the contents of a %G_TYPE_STRING #GValue.
181         *
182         * Returns: a newly allocated copy of the string content of @value
183         */
184        public string dupString()
185        {
186                auto retStr = g_value_dup_string(gValue);
187               
188                scope(exit) Str.freeString(retStr);
189                return Str.toString(retStr);
190        }
191
192        /**
193         * Get the contents of a variant #GValue, increasing its refcount.
194         *
195         * Returns: variant contents of @value, should be unrefed using
196         *     g_variant_unref() when no longer needed
197         *
198         * Since: 2.26
199         */
200        public Variant dupVariant()
201        {
202                auto p = g_value_dup_variant(gValue);
203               
204                if(p is null)
205                {
206                        return null;
207                }
208               
209                return new Variant(cast(GVariant*) p, true);
210        }
211
212        /**
213         * Determines if @value will fit inside the size of a pointer value.
214         * This is an internal function introduced mainly for C marshallers.
215         *
216         * Returns: %TRUE if @value will fit inside a pointer value.
217         */
218        public bool fitsPointer()
219        {
220                return g_value_fits_pointer(gValue) != 0;
221        }
222
223        /**
224         * Get the contents of a %G_TYPE_BOOLEAN #GValue.
225         *
226         * Returns: boolean contents of @value
227         */
228        public bool getBoolean()
229        {
230                return g_value_get_boolean(gValue) != 0;
231        }
232
233        /**
234         * Get the contents of a %G_TYPE_BOXED derived #GValue.
235         *
236         * Returns: boxed contents of @value
237         */
238        public void* getBoxed()
239        {
240                return g_value_get_boxed(gValue);
241        }
242
243        /**
244         * Do not use this function; it is broken on platforms where the %char
245         * type is unsigned, such as ARM and PowerPC.  See g_value_get_schar().
246         *
247         * Get the contents of a %G_TYPE_CHAR #GValue.
248         *
249         * Deprecated: This function's return type is broken, see g_value_get_schar()
250         *
251         * Returns: character contents of @value
252         */
253        public char getChar()
254        {
255                return g_value_get_char(gValue);
256        }
257
258        /**
259         * Get the contents of a %G_TYPE_DOUBLE #GValue.
260         *
261         * Returns: double contents of @value
262         */
263        public double getDouble()
264        {
265                return g_value_get_double(gValue);
266        }
267
268        /**
269         * Get the contents of a %G_TYPE_ENUM #GValue.
270         *
271         * Returns: enum contents of @value
272         */
273        public int getEnum()
274        {
275                return g_value_get_enum(gValue);
276        }
277
278        /**
279         * Get the contents of a %G_TYPE_FLAGS #GValue.
280         *
281         * Returns: flags contents of @value
282         */
283        public uint getFlags()
284        {
285                return g_value_get_flags(gValue);
286        }
287
288        /**
289         * Get the contents of a %G_TYPE_FLOAT #GValue.
290         *
291         * Returns: float contents of @value
292         */
293        public float getFloat()
294        {
295                return g_value_get_float(gValue);
296        }
297
298        /**
299         * Get the contents of a %G_TYPE_GTYPE #GValue.
300         *
301         * Returns: the #GType stored in @value
302         *
303         * Since: 2.12
304         */
305        public GType getGtype()
306        {
307                return g_value_get_gtype(gValue);
308        }
309
310        /**
311         * Get the contents of a %G_TYPE_INT #GValue.
312         *
313         * Returns: integer contents of @value
314         */
315        public int getInt()
316        {
317                return g_value_get_int(gValue);
318        }
319
320        /**
321         * Get the contents of a %G_TYPE_INT64 #GValue.
322         *
323         * Returns: 64bit integer contents of @value
324         */
325        public long getInt64()
326        {
327                return g_value_get_int64(gValue);
328        }
329
330        /**
331         * Get the contents of a %G_TYPE_LONG #GValue.
332         *
333         * Returns: long integer contents of @value
334         */
335        public glong getLong()
336        {
337                return g_value_get_long(gValue);
338        }
339
340        /**
341         * Get the contents of a %G_TYPE_OBJECT derived #GValue.
342         *
343         * Returns: object contents of @value
344         */
345        public ObjectG getObject()
346        {
347                auto p = g_value_get_object(gValue);
348               
349                if(p is null)
350                {
351                        return null;
352                }
353               
354                return ObjectG.getDObject!(ObjectG)(cast(GObject*) p);
355        }
356
357        /**
358         * Get the contents of a %G_TYPE_PARAM #GValue.
359         *
360         * Returns: #GParamSpec content of @value
361         */
362        public ParamSpec getParam()
363        {
364                auto p = g_value_get_param(gValue);
365               
366                if(p is null)
367                {
368                        return null;
369                }
370               
371                return ObjectG.getDObject!(ParamSpec)(cast(GParamSpec*) p);
372        }
373
374        /**
375         * Get the contents of a pointer #GValue.
376         *
377         * Returns: pointer contents of @value
378         */
379        public void* getPointer()
380        {
381                return g_value_get_pointer(gValue);
382        }
383
384        /**
385         * Get the contents of a %G_TYPE_CHAR #GValue.
386         *
387         * Returns: signed 8 bit integer contents of @value
388         *
389         * Since: 2.32
390         */
391        public byte getSchar()
392        {
393                return g_value_get_schar(gValue);
394        }
395
396        /**
397         * Get the contents of a %G_TYPE_STRING #GValue.
398         *
399         * Returns: string content of @value
400         */
401        public string getString()
402        {
403                return Str.toString(g_value_get_string(gValue));
404        }
405
406        /**
407         * Get the contents of a %G_TYPE_UCHAR #GValue.
408         *
409         * Returns: unsigned character contents of @value
410         */
411        public char getUchar()
412        {
413                return g_value_get_uchar(gValue);
414        }
415
416        /**
417         * Get the contents of a %G_TYPE_UINT #GValue.
418         *
419         * Returns: unsigned integer contents of @value
420         */
421        public uint getUint()
422        {
423                return g_value_get_uint(gValue);
424        }
425
426        /**
427         * Get the contents of a %G_TYPE_UINT64 #GValue.
428         *
429         * Returns: unsigned 64bit integer contents of @value
430         */
431        public ulong getUint64()
432        {
433                return g_value_get_uint64(gValue);
434        }
435
436        /**
437         * Get the contents of a %G_TYPE_ULONG #GValue.
438         *
439         * Returns: unsigned long integer contents of @value
440         */
441        public gulong getUlong()
442        {
443                return g_value_get_ulong(gValue);
444        }
445
446        /**
447         * Get the contents of a variant #GValue.
448         *
449         * Returns: variant contents of @value
450         *
451         * Since: 2.26
452         */
453        public Variant getVariant()
454        {
455                auto p = g_value_get_variant(gValue);
456               
457                if(p is null)
458                {
459                        return null;
460                }
461               
462                return new Variant(cast(GVariant*) p, true);
463        }
464
465        /**
466         * Initializes @value with the default value of @type.
467         *
468         * Params:
469         *     gType = Type the #GValue should hold values of.
470         *
471         * Returns: the #GValue structure that has been passed in
472         */
473        public Value init(GType gType)
474        {
475                auto p = g_value_init(gValue, gType);
476               
477                if(p is null)
478                {
479                        return null;
480                }
481               
482                return ObjectG.getDObject!(Value)(cast(GValue*) p);
483        }
484
485        /**
486         * Initializes and sets @value from an instantiatable type via the
487         * value_table's collect_value() function.
488         *
489         * Note: The @value will be initialised with the exact type of
490         * @instance.  If you wish to set the @value's type to a different GType
491         * (such as a parent class GType), you need to manually call
492         * g_value_init() and g_value_set_instance().
493         *
494         * Params:
495         *     instanc = the instance
496         *
497         * Since: 2.42
498         */
499        public void initFromInstance(void* instanc)
500        {
501                g_value_init_from_instance(gValue, instanc);
502        }
503
504        /**
505         * Returns the value contents as pointer. This function asserts that
506         * g_value_fits_pointer() returned %TRUE for the passed in value.
507         * This is an internal function introduced mainly for C marshallers.
508         *
509         * Returns: the value contents as pointer
510         */
511        public void* peekPointer()
512        {
513                return g_value_peek_pointer(gValue);
514        }
515
516        /**
517         * Clears the current value in @value and resets it to the default value
518         * (as if the value had just been initialized).
519         *
520         * Returns: the #GValue structure that has been passed in
521         */
522        public Value reset()
523        {
524                auto p = g_value_reset(gValue);
525               
526                if(p is null)
527                {
528                        return null;
529                }
530               
531                return ObjectG.getDObject!(Value)(cast(GValue*) p, true);
532        }
533
534        /**
535         * Set the contents of a %G_TYPE_BOOLEAN #GValue to @v_boolean.
536         *
537         * Params:
538         *     vBoolean = boolean value to be set
539         */
540        public void setBoolean(bool vBoolean)
541        {
542                g_value_set_boolean(gValue, vBoolean);
543        }
544
545        /**
546         * Set the contents of a %G_TYPE_BOXED derived #GValue to @v_boxed.
547         *
548         * Params:
549         *     vBoxed = boxed value to be set
550         */
551        public void setBoxed(void* vBoxed)
552        {
553                g_value_set_boxed(gValue, vBoxed);
554        }
555
556        /**
557         * This is an internal function introduced mainly for C marshallers.
558         *
559         * Deprecated: Use g_value_take_boxed() instead.
560         *
561         * Params:
562         *     vBoxed = duplicated unowned boxed value to be set
563         */
564        public void setBoxedTakeOwnership(void* vBoxed)
565        {
566                g_value_set_boxed_take_ownership(gValue, vBoxed);
567        }
568
569        /**
570         * Set the contents of a %G_TYPE_CHAR #GValue to @v_char.
571         *
572         * Deprecated: This function's input type is broken, see g_value_set_schar()
573         *
574         * Params:
575         *     vChar = character value to be set
576         */
577        public void setChar(char vChar)
578        {
579                g_value_set_char(gValue, vChar);
580        }
581
582        /**
583         * Set the contents of a %G_TYPE_DOUBLE #GValue to @v_double.
584         *
585         * Params:
586         *     vDouble = double value to be set
587         */
588        public void setDouble(double vDouble)
589        {
590                g_value_set_double(gValue, vDouble);
591        }
592
593        /**
594         * Set the contents of a %G_TYPE_ENUM #GValue to @v_enum.
595         *
596         * Params:
597         *     vEnum = enum value to be set
598         */
599        public void setEnum(int vEnum)
600        {
601                g_value_set_enum(gValue, vEnum);
602        }
603
604        /**
605         * Set the contents of a %G_TYPE_FLAGS #GValue to @v_flags.
606         *
607         * Params:
608         *     vFlags = flags value to be set
609         */
610        public void setFlags(uint vFlags)
611        {
612                g_value_set_flags(gValue, vFlags);
613        }
614
615        /**
616         * Set the contents of a %G_TYPE_FLOAT #GValue to @v_float.
617         *
618         * Params:
619         *     vFloat = float value to be set
620         */
621        public void setFloat(float vFloat)
622        {
623                g_value_set_float(gValue, vFloat);
624        }
625
626        /**
627         * Set the contents of a %G_TYPE_GTYPE #GValue to @v_gtype.
628         *
629         * Params:
630         *     vGtype = #GType to be set
631         *
632         * Since: 2.12
633         */
634        public void setGtype(GType vGtype)
635        {
636                g_value_set_gtype(gValue, vGtype);
637        }
638
639        /**
640         * Sets @value from an instantiatable type via the
641         * value_table's collect_value() function.
642         *
643         * Params:
644         *     instanc = the instance
645         */
646        public void setInstance(void* instanc)
647        {
648                g_value_set_instance(gValue, instanc);
649        }
650
651        /**
652         * Set the contents of a %G_TYPE_INT #GValue to @v_int.
653         *
654         * Params:
655         *     vInt = integer value to be set
656         */
657        public void setInt(int vInt)
658        {
659                g_value_set_int(gValue, vInt);
660        }
661
662        /**
663         * Set the contents of a %G_TYPE_INT64 #GValue to @v_int64.
664         *
665         * Params:
666         *     vInt64 = 64bit integer value to be set
667         */
668        public void setInt64(long vInt64)
669        {
670                g_value_set_int64(gValue, vInt64);
671        }
672
673        /**
674         * Set the contents of a %G_TYPE_LONG #GValue to @v_long.
675         *
676         * Params:
677         *     vLong = long integer value to be set
678         */
679        public void setLong(glong vLong)
680        {
681                g_value_set_long(gValue, vLong);
682        }
683
684        /**
685         * Set the contents of a %G_TYPE_OBJECT derived #GValue to @v_object.
686         *
687         * g_value_set_object() increases the reference count of @v_object
688         * (the #GValue holds a reference to @v_object).  If you do not wish
689         * to increase the reference count of the object (i.e. you wish to
690         * pass your current reference to the #GValue because you no longer
691         * need it), use g_value_take_object() instead.
692         *
693         * It is important that your #GValue holds a reference to @v_object (either its
694         * own, or one it has taken) to ensure that the object won't be destroyed while
695         * the #GValue still exists).
696         *
697         * Params:
698         *     vObject = object value to be set
699         */
700        public void setObject(ObjectG vObject)
701        {
702                g_value_set_object(gValue, (vObject is null) ? null : vObject.getObjectGStruct());
703        }
704
705        /**
706         * This is an internal function introduced mainly for C marshallers.
707         *
708         * Deprecated: Use g_value_take_object() instead.
709         *
710         * Params:
711         *     vObject = object value to be set
712         */
713        public void setObjectTakeOwnership(void* vObject)
714        {
715                g_value_set_object_take_ownership(gValue, vObject);
716        }
717
718        /**
719         * Set the contents of a %G_TYPE_PARAM #GValue to @param.
720         *
721         * Params:
722         *     param = the #GParamSpec to be set
723         */
724        public void setParam(ParamSpec param)
725        {
726                g_value_set_param(gValue, (param is null) ? null : param.getParamSpecStruct());
727        }
728
729        /**
730         * This is an internal function introduced mainly for C marshallers.
731         *
732         * Deprecated: Use g_value_take_param() instead.
733         *
734         * Params:
735         *     param = the #GParamSpec to be set
736         */
737        public void setParamTakeOwnership(ParamSpec param)
738        {
739                g_value_set_param_take_ownership(gValue, (param is null) ? null : param.getParamSpecStruct());
740        }
741
742        /**
743         * Set the contents of a pointer #GValue to @v_pointer.
744         *
745         * Params:
746         *     vPointer = pointer value to be set
747         */
748        public void setPointer(void* vPointer)
749        {
750                g_value_set_pointer(gValue, vPointer);
751        }
752
753        /**
754         * Set the contents of a %G_TYPE_CHAR #GValue to @v_char.
755         *
756         * Params:
757         *     vChar = signed 8 bit integer to be set
758         *
759         * Since: 2.32
760         */
761        public void setSchar(byte vChar)
762        {
763                g_value_set_schar(gValue, vChar);
764        }
765
766        /**
767         * Set the contents of a %G_TYPE_BOXED derived #GValue to @v_boxed.
768         * The boxed value is assumed to be static, and is thus not duplicated
769         * when setting the #GValue.
770         *
771         * Params:
772         *     vBoxed = static boxed value to be set
773         */
774        public void setStaticBoxed(void* vBoxed)
775        {
776                g_value_set_static_boxed(gValue, vBoxed);
777        }
778
779        /**
780         * Set the contents of a %G_TYPE_STRING #GValue to @v_string.
781         * The string is assumed to be static, and is thus not duplicated
782         * when setting the #GValue.
783         *
784         * Params:
785         *     vString = static string to be set
786         */
787        public void setStaticString(string vString)
788        {
789                g_value_set_static_string(gValue, Str.toStringz(vString));
790        }
791
792        /**
793         * Set the contents of a %G_TYPE_STRING #GValue to @v_string.
794         *
795         * Params:
796         *     vString = caller-owned string to be duplicated for the #GValue
797         */
798        public void setString(string vString)
799        {
800                g_value_set_string(gValue, Str.toStringz(vString));
801        }
802
803        /**
804         * This is an internal function introduced mainly for C marshallers.
805         *
806         * Deprecated: Use g_value_take_string() instead.
807         *
808         * Params:
809         *     vString = duplicated unowned string to be set
810         */
811        public void setStringTakeOwnership(string vString)
812        {
813                g_value_set_string_take_ownership(gValue, Str.toStringz(vString));
814        }
815
816        /**
817         * Set the contents of a %G_TYPE_UCHAR #GValue to @v_uchar.
818         *
819         * Params:
820         *     vUchar = unsigned character value to be set
821         */
822        public void setUchar(char vUchar)
823        {
824                g_value_set_uchar(gValue, vUchar);
825        }
826
827        /**
828         * Set the contents of a %G_TYPE_UINT #GValue to @v_uint.
829         *
830         * Params:
831         *     vUint = unsigned integer value to be set
832         */
833        public void setUint(uint vUint)
834        {
835                g_value_set_uint(gValue, vUint);
836        }
837
838        /**
839         * Set the contents of a %G_TYPE_UINT64 #GValue to @v_uint64.
840         *
841         * Params:
842         *     vUint64 = unsigned 64bit integer value to be set
843         */
844        public void setUint64(ulong vUint64)
845        {
846                g_value_set_uint64(gValue, vUint64);
847        }
848
849        /**
850         * Set the contents of a %G_TYPE_ULONG #GValue to @v_ulong.
851         *
852         * Params:
853         *     vUlong = unsigned long integer value to be set
854         */
855        public void setUlong(gulong vUlong)
856        {
857                g_value_set_ulong(gValue, vUlong);
858        }
859
860        /**
861         * Set the contents of a variant #GValue to @variant.
862         * If the variant is floating, it is consumed.
863         *
864         * Params:
865         *     variant = a #GVariant, or %NULL
866         *
867         * Since: 2.26
868         */
869        public void setVariant(Variant variant)
870        {
871                g_value_set_variant(gValue, (variant is null) ? null : variant.getVariantStruct());
872        }
873
874        /**
875         * Sets the contents of a %G_TYPE_BOXED derived #GValue to @v_boxed
876         * and takes over the ownership of the callers reference to @v_boxed;
877         * the caller doesn't have to unref it any more.
878         *
879         * Params:
880         *     vBoxed = duplicated unowned boxed value to be set
881         *
882         * Since: 2.4
883         */
884        public void takeBoxed(void* vBoxed)
885        {
886                g_value_take_boxed(gValue, vBoxed);
887        }
888
889        /**
890         * Sets the contents of a %G_TYPE_OBJECT derived #GValue to @v_object
891         * and takes over the ownership of the callers reference to @v_object;
892         * the caller doesn't have to unref it any more (i.e. the reference
893         * count of the object is not increased).
894         *
895         * If you want the #GValue to hold its own reference to @v_object, use
896         * g_value_set_object() instead.
897         *
898         * Params:
899         *     vObject = object value to be set
900         *
901         * Since: 2.4
902         */
903        public void takeObject(void* vObject)
904        {
905                g_value_take_object(gValue, vObject);
906        }
907
908        /**
909         * Sets the contents of a %G_TYPE_PARAM #GValue to @param and takes
910         * over the ownership of the callers reference to @param; the caller
911         * doesn't have to unref it any more.
912         *
913         * Params:
914         *     param = the #GParamSpec to be set
915         *
916         * Since: 2.4
917         */
918        public void takeParam(ParamSpec param)
919        {
920                g_value_take_param(gValue, (param is null) ? null : param.getParamSpecStruct());
921        }
922
923        /**
924         * Sets the contents of a %G_TYPE_STRING #GValue to @v_string.
925         *
926         * Params:
927         *     vString = string to take ownership of
928         *
929         * Since: 2.4
930         */
931        public void takeString(string vString)
932        {
933                g_value_take_string(gValue, Str.toStringz(vString));
934        }
935
936        /**
937         * Set the contents of a variant #GValue to @variant, and takes over
938         * the ownership of the caller's reference to @variant;
939         * the caller doesn't have to unref it any more (i.e. the reference
940         * count of the variant is not increased).
941         *
942         * If @variant was floating then its floating reference is converted to
943         * a hard reference.
944         *
945         * If you want the #GValue to hold its own reference to @variant, use
946         * g_value_set_variant() instead.
947         *
948         * This is an internal function introduced mainly for C marshallers.
949         *
950         * Params:
951         *     variant = a #GVariant, or %NULL
952         *
953         * Since: 2.26
954         */
955        public void takeVariant(Variant variant)
956        {
957                g_value_take_variant(gValue, (variant is null) ? null : variant.getVariantStruct());
958        }
959
960        /**
961         * Tries to cast the contents of @src_value into a type appropriate
962         * to store in @dest_value, e.g. to transform a %G_TYPE_INT value
963         * into a %G_TYPE_FLOAT value. Performing transformations between
964         * value types might incur precision lossage. Especially
965         * transformations into strings might reveal seemingly arbitrary
966         * results and shouldn't be relied upon for production code (such
967         * as rcfile value or object property serialization).
968         *
969         * Params:
970         *     destValue = Target value.
971         *
972         * Returns: Whether a transformation rule was found and could be applied.
973         *     Upon failing transformations, @dest_value is left untouched.
974         */
975        public bool transform(Value destValue)
976        {
977                return g_value_transform(gValue, (destValue is null) ? null : destValue.getValueStruct()) != 0;
978        }
979
980        /**
981         * Clears the current value in @value and "unsets" the type,
982         * this releases all resources associated with this GValue.
983         * An unset value is the same as an uninitialized (zero-filled)
984         * #GValue structure.
985         */
986        public void unset()
987        {
988                g_value_unset(gValue);
989        }
990
991        /**
992         * Registers a value transformation function for use in g_value_transform().
993         * A previously registered transformation function for @src_type and @dest_type
994         * will be replaced.
995         *
996         * Params:
997         *     srcType = Source type.
998         *     destType = Target type.
999         *     transformFunc = a function which transforms values of type @src_type
1000         *         into value of type @dest_type
1001         */
1002        public static void registerTransformFunc(GType srcType, GType destType, GValueTransform transformFunc)
1003        {
1004                g_value_register_transform_func(srcType, destType, transformFunc);
1005        }
1006
1007        /**
1008         * Returns whether a #GValue of type @src_type can be copied into
1009         * a #GValue of type @dest_type.
1010         *
1011         * Params:
1012         *     srcType = source type to be copied.
1013         *     destType = destination type for copying.
1014         *
1015         * Returns: %TRUE if g_value_copy() is possible with @src_type and @dest_type.
1016         */
1017        public static bool typeCompatible(GType srcType, GType destType)
1018        {
1019                return g_value_type_compatible(srcType, destType) != 0;
1020        }
1021
1022        /**
1023         * Check whether g_value_transform() is able to transform values
1024         * of type @src_type into values of type @dest_type. Note that for
1025         * the types to be transformable, they must be compatible and a
1026         * transform function must be registered.
1027         *
1028         * Params:
1029         *     srcType = Source type.
1030         *     destType = Target type.
1031         *
1032         * Returns: %TRUE if the transformation is possible, %FALSE otherwise.
1033         */
1034        public static bool typeTransformable(GType srcType, GType destType)
1035        {
1036                return g_value_type_transformable(srcType, destType) != 0;
1037        }
1038
1039        /**
1040         * Creates a new #GParamSpecBoolean instance specifying a %G_TYPE_BOOLEAN
1041         * property. In many cases, it may be more appropriate to use an enum with
1042         * g_param_spec_enum(), both to improve code clarity by using explicitly named
1043         * values, and to allow for more values to be added in future without breaking
1044         * API.
1045         *
1046         * See g_param_spec_internal() for details on property names.
1047         *
1048         * Params:
1049         *     name = canonical name of the property specified
1050         *     nick = nick name for the property specified
1051         *     blurb = description of the property specified
1052         *     defaultValue = default value for the property specified
1053         *     flags = flags for the property specified
1054         *
1055         * Returns: a newly created parameter specification
1056         */
1057        public static ParamSpec paramSpecBoolean(string name, string nick, string blurb, bool defaultValue, GParamFlags flags)
1058        {
1059                auto p = g_param_spec_boolean(Str.toStringz(name), Str.toStringz(nick), Str.toStringz(blurb), defaultValue, flags);
1060               
1061                if(p is null)
1062                {
1063                        return null;
1064                }
1065               
1066                return ObjectG.getDObject!(ParamSpec)(cast(GParamSpec*) p, true);
1067        }
1068
1069        /**
1070         * Creates a new #GParamSpecBoxed instance specifying a %G_TYPE_BOXED
1071         * derived property.
1072         *
1073         * See g_param_spec_internal() for details on property names.
1074         *
1075         * Params:
1076         *     name = canonical name of the property specified
1077         *     nick = nick name for the property specified
1078         *     blurb = description of the property specified
1079         *     boxedType = %G_TYPE_BOXED derived type of this property
1080         *     flags = flags for the property specified
1081         *
1082         * Returns: a newly created parameter specification
1083         */
1084        public static ParamSpec paramSpecBoxed(string name, string nick, string blurb, GType boxedType, GParamFlags flags)
1085        {
1086                auto p = g_param_spec_boxed(Str.toStringz(name), Str.toStringz(nick), Str.toStringz(blurb), boxedType, flags);
1087               
1088                if(p is null)
1089                {
1090                        return null;
1091                }
1092               
1093                return ObjectG.getDObject!(ParamSpec)(cast(GParamSpec*) p, true);
1094        }
1095
1096        /**
1097         * Creates a new #GParamSpecChar instance specifying a %G_TYPE_CHAR property.
1098         *
1099         * Params:
1100         *     name = canonical name of the property specified
1101         *     nick = nick name for the property specified
1102         *     blurb = description of the property specified
1103         *     minimum = minimum value for the property specified
1104         *     maximum = maximum value for the property specified
1105         *     defaultValue = default value for the property specified
1106         *     flags = flags for the property specified
1107         *
1108         * Returns: a newly created parameter specification
1109         */
1110        public static ParamSpec paramSpecChar(string name, string nick, string blurb, byte minimum, byte maximum, byte defaultValue, GParamFlags flags)
1111        {
1112                auto p = g_param_spec_char(Str.toStringz(name), Str.toStringz(nick), Str.toStringz(blurb), minimum, maximum, defaultValue, flags);
1113               
1114                if(p is null)
1115                {
1116                        return null;
1117                }
1118               
1119                return ObjectG.getDObject!(ParamSpec)(cast(GParamSpec*) p, true);
1120        }
1121
1122        /**
1123         * Creates a new #GParamSpecDouble instance specifying a %G_TYPE_DOUBLE
1124         * property.
1125         *
1126         * See g_param_spec_internal() for details on property names.
1127         *
1128         * Params:
1129         *     name = canonical name of the property specified
1130         *     nick = nick name for the property specified
1131         *     blurb = description of the property specified
1132         *     minimum = minimum value for the property specified
1133         *     maximum = maximum value for the property specified
1134         *     defaultValue = default value for the property specified
1135         *     flags = flags for the property specified
1136         *
1137         * Returns: a newly created parameter specification
1138         */
1139        public static ParamSpec paramSpecDouble(string name, string nick, string blurb, double minimum, double maximum, double defaultValue, GParamFlags flags)
1140        {
1141                auto p = g_param_spec_double(Str.toStringz(name), Str.toStringz(nick), Str.toStringz(blurb), minimum, maximum, defaultValue, flags);
1142               
1143                if(p is null)
1144                {
1145                        return null;
1146                }
1147               
1148                return ObjectG.getDObject!(ParamSpec)(cast(GParamSpec*) p, true);
1149        }
1150
1151        /**
1152         * Creates a new #GParamSpecEnum instance specifying a %G_TYPE_ENUM
1153         * property.
1154         *
1155         * See g_param_spec_internal() for details on property names.
1156         *
1157         * Params:
1158         *     name = canonical name of the property specified
1159         *     nick = nick name for the property specified
1160         *     blurb = description of the property specified
1161         *     enumType = a #GType derived from %G_TYPE_ENUM
1162         *     defaultValue = default value for the property specified
1163         *     flags = flags for the property specified
1164         *
1165         * Returns: a newly created parameter specification
1166         */
1167        public static ParamSpec paramSpecEnum(string name, string nick, string blurb, GType enumType, int defaultValue, GParamFlags flags)
1168        {
1169                auto p = g_param_spec_enum(Str.toStringz(name), Str.toStringz(nick), Str.toStringz(blurb), enumType, defaultValue, flags);
1170               
1171                if(p is null)
1172                {
1173                        return null;
1174                }
1175               
1176                return ObjectG.getDObject!(ParamSpec)(cast(GParamSpec*) p, true);
1177        }
1178
1179        /**
1180         * Creates a new #GParamSpecFlags instance specifying a %G_TYPE_FLAGS
1181         * property.
1182         *
1183         * See g_param_spec_internal() for details on property names.
1184         *
1185         * Params:
1186         *     name = canonical name of the property specified
1187         *     nick = nick name for the property specified
1188         *     blurb = description of the property specified
1189         *     flagsType = a #GType derived from %G_TYPE_FLAGS
1190         *     defaultValue = default value for the property specified
1191         *     flags = flags for the property specified
1192         *
1193         * Returns: a newly created parameter specification
1194         */
1195        public static ParamSpec paramSpecFlags(string name, string nick, string blurb, GType flagsType, uint defaultValue, GParamFlags flags)
1196        {
1197                auto p = g_param_spec_flags(Str.toStringz(name), Str.toStringz(nick), Str.toStringz(blurb), flagsType, defaultValue, flags);
1198               
1199                if(p is null)
1200                {
1201                        return null;
1202                }
1203               
1204                return ObjectG.getDObject!(ParamSpec)(cast(GParamSpec*) p, true);
1205        }
1206
1207        /**
1208         * Creates a new #GParamSpecFloat instance specifying a %G_TYPE_FLOAT property.
1209         *
1210         * See g_param_spec_internal() for details on property names.
1211         *
1212         * Params:
1213         *     name = canonical name of the property specified
1214         *     nick = nick name for the property specified
1215         *     blurb = description of the property specified
1216         *     minimum = minimum value for the property specified
1217         *     maximum = maximum value for the property specified
1218         *     defaultValue = default value for the property specified
1219         *     flags = flags for the property specified
1220         *
1221         * Returns: a newly created parameter specification
1222         */
1223        public static ParamSpec paramSpecFloat(string name, string nick, string blurb, float minimum, float maximum, float defaultValue, GParamFlags flags)
1224        {
1225                auto p = g_param_spec_float(Str.toStringz(name), Str.toStringz(nick), Str.toStringz(blurb), minimum, maximum, defaultValue, flags);
1226               
1227                if(p is null)
1228                {
1229                        return null;
1230                }
1231               
1232                return ObjectG.getDObject!(ParamSpec)(cast(GParamSpec*) p, true);
1233        }
1234
1235        /**
1236         * Creates a new #GParamSpecGType instance specifying a
1237         * %G_TYPE_GTYPE property.
1238         *
1239         * See g_param_spec_internal() for details on property names.
1240         *
1241         * Params:
1242         *     name = canonical name of the property specified
1243         *     nick = nick name for the property specified
1244         *     blurb = description of the property specified
1245         *     isAType = a #GType whose subtypes are allowed as values
1246         *         of the property (use %G_TYPE_NONE for any type)
1247         *     flags = flags for the property specified
1248         *
1249         * Returns: a newly created parameter specification
1250         *
1251         * Since: 2.10
1252         */
1253        public static ParamSpec paramSpecGtype(string name, string nick, string blurb, GType isAType, GParamFlags flags)
1254        {
1255                auto p = g_param_spec_gtype(Str.toStringz(name), Str.toStringz(nick), Str.toStringz(blurb), isAType, flags);
1256               
1257                if(p is null)
1258                {
1259                        return null;
1260                }
1261               
1262                return ObjectG.getDObject!(ParamSpec)(cast(GParamSpec*) p, true);
1263        }
1264
1265        /**
1266         * Creates a new #GParamSpecInt instance specifying a %G_TYPE_INT property.
1267         *
1268         * See g_param_spec_internal() for details on property names.
1269         *
1270         * Params:
1271         *     name = canonical name of the property specified
1272         *     nick = nick name for the property specified
1273         *     blurb = description of the property specified
1274         *     minimum = minimum value for the property specified
1275         *     maximum = maximum value for the property specified
1276         *     defaultValue = default value for the property specified
1277         *     flags = flags for the property specified
1278         *
1279         * Returns: a newly created parameter specification
1280         */
1281        public static ParamSpec paramSpecInt(string name, string nick, string blurb, int minimum, int maximum, int defaultValue, GParamFlags flags)
1282        {
1283                auto p = g_param_spec_int(Str.toStringz(name), Str.toStringz(nick), Str.toStringz(blurb), minimum, maximum, defaultValue, flags);
1284               
1285                if(p is null)
1286                {
1287                        return null;
1288                }
1289               
1290                return ObjectG.getDObject!(ParamSpec)(cast(GParamSpec*) p, true);
1291        }
1292
1293        /**
1294         * Creates a new #GParamSpecInt64 instance specifying a %G_TYPE_INT64 property.
1295         *
1296         * See g_param_spec_internal() for details on property names.
1297         *
1298         * Params:
1299         *     name = canonical name of the property specified
1300         *     nick = nick name for the property specified
1301         *     blurb = description of the property specified
1302         *     minimum = minimum value for the property specified
1303         *     maximum = maximum value for the property specified
1304         *     defaultValue = default value for the property specified
1305         *     flags = flags for the property specified
1306         *
1307         * Returns: a newly created parameter specification
1308         */
1309        public static ParamSpec paramSpecInt64(string name, string nick, string blurb, long minimum, long maximum, long defaultValue, GParamFlags flags)
1310        {
1311                auto p = g_param_spec_int64(Str.toStringz(name), Str.toStringz(nick), Str.toStringz(blurb), minimum, maximum, defaultValue, flags);
1312               
1313                if(p is null)
1314                {
1315                        return null;
1316                }
1317               
1318                return ObjectG.getDObject!(ParamSpec)(cast(GParamSpec*) p, true);
1319        }
1320
1321        /**
1322         * Creates a new #GParamSpecLong instance specifying a %G_TYPE_LONG property.
1323         *
1324         * See g_param_spec_internal() for details on property names.
1325         *
1326         * Params:
1327         *     name = canonical name of the property specified
1328         *     nick = nick name for the property specified
1329         *     blurb = description of the property specified
1330         *     minimum = minimum value for the property specified
1331         *     maximum = maximum value for the property specified
1332         *     defaultValue = default value for the property specified
1333         *     flags = flags for the property specified
1334         *
1335         * Returns: a newly created parameter specification
1336         */
1337        public static ParamSpec paramSpecLong(string name, string nick, string blurb, glong minimum, glong maximum, glong defaultValue, GParamFlags flags)
1338        {
1339                auto p = g_param_spec_long(Str.toStringz(name), Str.toStringz(nick), Str.toStringz(blurb), minimum, maximum, defaultValue, flags);
1340               
1341                if(p is null)
1342                {
1343                        return null;
1344                }
1345               
1346                return ObjectG.getDObject!(ParamSpec)(cast(GParamSpec*) p, true);
1347        }
1348
1349        /**
1350         * Creates a new #GParamSpecBoxed instance specifying a %G_TYPE_OBJECT
1351         * derived property.
1352         *
1353         * See g_param_spec_internal() for details on property names.
1354         *
1355         * Params:
1356         *     name = canonical name of the property specified
1357         *     nick = nick name for the property specified
1358         *     blurb = description of the property specified
1359         *     objectType = %G_TYPE_OBJECT derived type of this property
1360         *     flags = flags for the property specified
1361         *
1362         * Returns: a newly created parameter specification
1363         */
1364        public static ParamSpec paramSpecObject(string name, string nick, string blurb, GType objectType, GParamFlags flags)
1365        {
1366                auto p = g_param_spec_object(Str.toStringz(name), Str.toStringz(nick), Str.toStringz(blurb), objectType, flags);
1367               
1368                if(p is null)
1369                {
1370                        return null;
1371                }
1372               
1373                return ObjectG.getDObject!(ParamSpec)(cast(GParamSpec*) p, true);
1374        }
1375
1376        /**
1377         * Creates a new property of type #GParamSpecOverride. This is used
1378         * to direct operations to another paramspec, and will not be directly
1379         * useful unless you are implementing a new base type similar to GObject.
1380         *
1381         * Params:
1382         *     name = the name of the property.
1383         *     overridden = The property that is being overridden
1384         *
1385         * Returns: the newly created #GParamSpec
1386         *
1387         * Since: 2.4
1388         */
1389        public static ParamSpec paramSpecOverride(string name, ParamSpec overridden)
1390        {
1391                auto p = g_param_spec_override(Str.toStringz(name), (overridden is null) ? null : overridden.getParamSpecStruct());
1392               
1393                if(p is null)
1394                {
1395                        return null;
1396                }
1397               
1398                return ObjectG.getDObject!(ParamSpec)(cast(GParamSpec*) p);
1399        }
1400
1401        /**
1402         * Creates a new #GParamSpecParam instance specifying a %G_TYPE_PARAM
1403         * property.
1404         *
1405         * See g_param_spec_internal() for details on property names.
1406         *
1407         * Params:
1408         *     name = canonical name of the property specified
1409         *     nick = nick name for the property specified
1410         *     blurb = description of the property specified
1411         *     paramType = a #GType derived from %G_TYPE_PARAM
1412         *     flags = flags for the property specified
1413         *
1414         * Returns: a newly created parameter specification
1415         */
1416        public static ParamSpec paramSpecParam(string name, string nick, string blurb, GType paramType, GParamFlags flags)
1417        {
1418                auto p = g_param_spec_param(Str.toStringz(name), Str.toStringz(nick), Str.toStringz(blurb), paramType, flags);
1419               
1420                if(p is null)
1421                {
1422                        return null;
1423                }
1424               
1425                return ObjectG.getDObject!(ParamSpec)(cast(GParamSpec*) p, true);
1426        }
1427
1428        /**
1429         * Creates a new #GParamSpecPointer instance specifying a pointer property.
1430         * Where possible, it is better to use g_param_spec_object() or
1431         * g_param_spec_boxed() to expose memory management information.
1432         *
1433         * See g_param_spec_internal() for details on property names.
1434         *
1435         * Params:
1436         *     name = canonical name of the property specified
1437         *     nick = nick name for the property specified
1438         *     blurb = description of the property specified
1439         *     flags = flags for the property specified
1440         *
1441         * Returns: a newly created parameter specification
1442         */
1443        public static ParamSpec paramSpecPointer(string name, string nick, string blurb, GParamFlags flags)
1444        {
1445                auto p = g_param_spec_pointer(Str.toStringz(name), Str.toStringz(nick), Str.toStringz(blurb), flags);
1446               
1447                if(p is null)
1448                {
1449                        return null;
1450                }
1451               
1452                return ObjectG.getDObject!(ParamSpec)(cast(GParamSpec*) p, true);
1453        }
1454
1455        /**
1456         * Creates a new #GParamSpecString instance.
1457         *
1458         * See g_param_spec_internal() for details on property names.
1459         *
1460         * Params:
1461         *     name = canonical name of the property specified
1462         *     nick = nick name for the property specified
1463         *     blurb = description of the property specified
1464         *     defaultValue = default value for the property specified
1465         *     flags = flags for the property specified
1466         *
1467         * Returns: a newly created parameter specification
1468         */
1469        public static ParamSpec paramSpecString(string name, string nick, string blurb, string defaultValue, GParamFlags flags)
1470        {
1471                auto p = g_param_spec_string(Str.toStringz(name), Str.toStringz(nick), Str.toStringz(blurb), Str.toStringz(defaultValue), flags);
1472               
1473                if(p is null)
1474                {
1475                        return null;
1476                }
1477               
1478                return ObjectG.getDObject!(ParamSpec)(cast(GParamSpec*) p, true);
1479        }
1480
1481        /**
1482         * Creates a new #GParamSpecUChar instance specifying a %G_TYPE_UCHAR property.
1483         *
1484         * Params:
1485         *     name = canonical name of the property specified
1486         *     nick = nick name for the property specified
1487         *     blurb = description of the property specified
1488         *     minimum = minimum value for the property specified
1489         *     maximum = maximum value for the property specified
1490         *     defaultValue = default value for the property specified
1491         *     flags = flags for the property specified
1492         *
1493         * Returns: a newly created parameter specification
1494         */
1495        public static ParamSpec paramSpecUchar(string name, string nick, string blurb, ubyte minimum, ubyte maximum, ubyte defaultValue, GParamFlags flags)
1496        {
1497                auto p = g_param_spec_uchar(Str.toStringz(name), Str.toStringz(nick), Str.toStringz(blurb), minimum, maximum, defaultValue, flags);
1498               
1499                if(p is null)
1500                {
1501                        return null;
1502                }
1503               
1504                return ObjectG.getDObject!(ParamSpec)(cast(GParamSpec*) p, true);
1505        }
1506
1507        /**
1508         * Creates a new #GParamSpecUInt instance specifying a %G_TYPE_UINT property.
1509         *
1510         * See g_param_spec_internal() for details on property names.
1511         *
1512         * Params:
1513         *     name = canonical name of the property specified
1514         *     nick = nick name for the property specified
1515         *     blurb = description of the property specified
1516         *     minimum = minimum value for the property specified
1517         *     maximum = maximum value for the property specified
1518         *     defaultValue = default value for the property specified
1519         *     flags = flags for the property specified
1520         *
1521         * Returns: a newly created parameter specification
1522         */
1523        public static ParamSpec paramSpecUint(string name, string nick, string blurb, uint minimum, uint maximum, uint defaultValue, GParamFlags flags)
1524        {
1525                auto p = g_param_spec_uint(Str.toStringz(name), Str.toStringz(nick), Str.toStringz(blurb), minimum, maximum, defaultValue, flags);
1526               
1527                if(p is null)
1528                {
1529                        return null;
1530                }
1531               
1532                return ObjectG.getDObject!(ParamSpec)(cast(GParamSpec*) p, true);
1533        }
1534
1535        /**
1536         * Creates a new #GParamSpecUInt64 instance specifying a %G_TYPE_UINT64
1537         * property.
1538         *
1539         * See g_param_spec_internal() for details on property names.
1540         *
1541         * Params:
1542         *     name = canonical name of the property specified
1543         *     nick = nick name for the property specified
1544         *     blurb = description of the property specified
1545         *     minimum = minimum value for the property specified
1546         *     maximum = maximum value for the property specified
1547         *     defaultValue = default value for the property specified
1548         *     flags = flags for the property specified
1549         *
1550         * Returns: a newly created parameter specification
1551         */
1552        public static ParamSpec paramSpecUint64(string name, string nick, string blurb, ulong minimum, ulong maximum, ulong defaultValue, GParamFlags flags)
1553        {
1554                auto p = g_param_spec_uint64(Str.toStringz(name), Str.toStringz(nick), Str.toStringz(blurb), minimum, maximum, defaultValue, flags);
1555               
1556                if(p is null)
1557                {
1558                        return null;
1559                }
1560               
1561                return ObjectG.getDObject!(ParamSpec)(cast(GParamSpec*) p, true);
1562        }
1563
1564        /**
1565         * Creates a new #GParamSpecULong instance specifying a %G_TYPE_ULONG
1566         * property.
1567         *
1568         * See g_param_spec_internal() for details on property names.
1569         *
1570         * Params:
1571         *     name = canonical name of the property specified
1572         *     nick = nick name for the property specified
1573         *     blurb = description of the property specified
1574         *     minimum = minimum value for the property specified
1575         *     maximum = maximum value for the property specified
1576         *     defaultValue = default value for the property specified
1577         *     flags = flags for the property specified
1578         *
1579         * Returns: a newly created parameter specification
1580         */
1581        public static ParamSpec paramSpecUlong(string name, string nick, string blurb, gulong minimum, gulong maximum, gulong defaultValue, GParamFlags flags)
1582        {
1583                auto p = g_param_spec_ulong(Str.toStringz(name), Str.toStringz(nick), Str.toStringz(blurb), minimum, maximum, defaultValue, flags);
1584               
1585                if(p is null)
1586                {
1587                        return null;
1588                }
1589               
1590                return ObjectG.getDObject!(ParamSpec)(cast(GParamSpec*) p, true);
1591        }
1592
1593        /**
1594         * Creates a new #GParamSpecUnichar instance specifying a %G_TYPE_UINT
1595         * property. #GValue structures for this property can be accessed with
1596         * g_value_set_uint() and g_value_get_uint().
1597         *
1598         * See g_param_spec_internal() for details on property names.
1599         *
1600         * Params:
1601         *     name = canonical name of the property specified
1602         *     nick = nick name for the property specified
1603         *     blurb = description of the property specified
1604         *     defaultValue = default value for the property specified
1605         *     flags = flags for the property specified
1606         *
1607         * Returns: a newly created parameter specification
1608         */
1609        public static ParamSpec paramSpecUnichar(string name, string nick, string blurb, dchar defaultValue, GParamFlags flags)
1610        {
1611                auto p = g_param_spec_unichar(Str.toStringz(name), Str.toStringz(nick), Str.toStringz(blurb), defaultValue, flags);
1612               
1613                if(p is null)
1614                {
1615                        return null;
1616                }
1617               
1618                return ObjectG.getDObject!(ParamSpec)(cast(GParamSpec*) p, true);
1619        }
1620
1621        /**
1622         * Creates a new #GParamSpecValueArray instance specifying a
1623         * %G_TYPE_VALUE_ARRAY property. %G_TYPE_VALUE_ARRAY is a
1624         * %G_TYPE_BOXED type, as such, #GValue structures for this property
1625         * can be accessed with g_value_set_boxed() and g_value_get_boxed().
1626         *
1627         * See g_param_spec_internal() for details on property names.
1628         *
1629         * Params:
1630         *     name = canonical name of the property specified
1631         *     nick = nick name for the property specified
1632         *     blurb = description of the property specified
1633         *     elementSpec = a #GParamSpec describing the elements contained in
1634         *         arrays of this property, may be %NULL
1635         *     flags = flags for the property specified
1636         *
1637         * Returns: a newly created parameter specification
1638         */
1639        public static ParamSpec paramSpecValueArray(string name, string nick, string blurb, ParamSpec elementSpec, GParamFlags flags)
1640        {
1641                auto p = g_param_spec_value_array(Str.toStringz(name), Str.toStringz(nick), Str.toStringz(blurb), (elementSpec is null) ? null : elementSpec.getParamSpecStruct(), flags);
1642               
1643                if(p is null)
1644                {
1645                        return null;
1646                }
1647               
1648                return ObjectG.getDObject!(ParamSpec)(cast(GParamSpec*) p);
1649        }
1650
1651        /**
1652         * Creates a new #GParamSpecVariant instance specifying a #GVariant
1653         * property.
1654         *
1655         * If @default_value is floating, it is consumed.
1656         *
1657         * See g_param_spec_internal() for details on property names.
1658         *
1659         * Params:
1660         *     name = canonical name of the property specified
1661         *     nick = nick name for the property specified
1662         *     blurb = description of the property specified
1663         *     type = a #GVariantType
1664         *     defaultValue = a #GVariant of type @type to
1665         *         use as the default value, or %NULL
1666         *     flags = flags for the property specified
1667         *
1668         * Returns: the newly created #GParamSpec
1669         *
1670         * Since: 2.26
1671         */
1672        public static ParamSpec paramSpecVariant(string name, string nick, string blurb, VariantType type, Variant defaultValue, GParamFlags flags)
1673        {
1674                auto p = g_param_spec_variant(Str.toStringz(name), Str.toStringz(nick), Str.toStringz(blurb), (type is null) ? null : type.getVariantTypeStruct(), (defaultValue is null) ? null : defaultValue.getVariantStruct(), flags);
1675               
1676                if(p is null)
1677                {
1678                        return null;
1679                }
1680               
1681                return ObjectG.getDObject!(ParamSpec)(cast(GParamSpec*) p, true);
1682        }
1683
1684        /**
1685         * Return a newly allocated string, which describes the contents of a
1686         * #GValue.  The main purpose of this function is to describe #GValue
1687         * contents for debugging output, the way in which the contents are
1688         * described may change between different GLib versions.
1689         *
1690         * Params:
1691         *     value = #GValue which contents are to be described.
1692         *
1693         * Returns: Newly allocated string.
1694         */
1695        public static string strdupValueContents(Value value)
1696        {
1697                auto retStr = g_strdup_value_contents((value is null) ? null : value.getValueStruct());
1698               
1699                scope(exit) Str.freeString(retStr);
1700                return Str.toString(retStr);
1701        }
1702}
Note: See TracBrowser for help on using the repository browser.