glib/
param_spec.rs

1// Copyright 2018, The Gtk-rs Project Developers.
2// See the COPYRIGHT file at the top-level directory of this distribution.
3// Licensed under the MIT license, see the LICENSE file or <http://opensource.org/licenses/MIT>
4//
5// TODO: Implement custom subtyping here for things like GParamSpecInt to get
6// default/min/max values and similar
7use gobject_sys;
8use libc;
9use translate::*;
10use ParamFlags;
11use Value;
12
13glib_wrapper! {
14    #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
15    pub struct ParamSpec(Shared<gobject_sys::GParamSpec>);
16
17    match fn {
18        ref => |ptr| gobject_sys::g_param_spec_ref_sink(ptr),
19        unref => |ptr| gobject_sys::g_param_spec_unref(ptr),
20        get_type => || gobject_sys::G_TYPE_PARAM,
21    }
22}
23
24unsafe impl Send for ParamSpec {}
25unsafe impl Sync for ParamSpec {}
26
27impl ParamSpec {
28    pub fn get_value_type(&self) -> ::Type {
29        unsafe { from_glib((*self.to_glib_none().0).value_type) }
30    }
31
32    pub fn get_owner_type(&self) -> ::Type {
33        unsafe { from_glib((*self.to_glib_none().0).owner_type) }
34    }
35
36    pub fn get_flags(&self) -> ParamFlags {
37        unsafe { from_glib((*self.to_glib_none().0).flags) }
38    }
39
40    pub fn get_blurb(&self) -> String {
41        unsafe { from_glib_none(gobject_sys::g_param_spec_get_blurb(self.to_glib_none().0)) }
42    }
43
44    pub fn get_default_value(&self) -> Option<Value> {
45        unsafe {
46            from_glib_none(gobject_sys::g_param_spec_get_default_value(
47                self.to_glib_none().0,
48            ))
49        }
50    }
51
52    pub fn get_name(&self) -> String {
53        unsafe { from_glib_none(gobject_sys::g_param_spec_get_name(self.to_glib_none().0)) }
54    }
55
56    #[cfg(any(feature = "v2_46", feature = "dox"))]
57    pub fn get_name_quark(&self) -> ::Quark {
58        unsafe {
59            from_glib(gobject_sys::g_param_spec_get_name_quark(
60                self.to_glib_none().0,
61            ))
62        }
63    }
64
65    pub fn get_nick(&self) -> String {
66        unsafe { from_glib_none(gobject_sys::g_param_spec_get_nick(self.to_glib_none().0)) }
67    }
68
69    //pub fn get_qdata(&self, quark: /*Ignored*/glib::Quark) -> /*Unimplemented*/Option<Fundamental: Pointer> {
70    //    unsafe { TODO: call gobject_sys::g_param_spec_get_qdata() }
71    //}
72
73    pub fn get_redirect_target(&self) -> Option<ParamSpec> {
74        unsafe {
75            from_glib_none(gobject_sys::g_param_spec_get_redirect_target(
76                self.to_glib_none().0,
77            ))
78        }
79    }
80
81    //pub fn set_qdata(&self, quark: /*Ignored*/glib::Quark, data: Option</*Unimplemented*/Fundamental: Pointer>) {
82    //    unsafe { TODO: call gobject_sys::g_param_spec_set_qdata() }
83    //}
84
85    //pub fn set_qdata_full(&self, quark: /*Ignored*/glib::Quark, data: Option</*Unimplemented*/Fundamental: Pointer>, destroy: /*Unknown conversion*//*Unimplemented*/DestroyNotify) {
86    //    unsafe { TODO: call gobject_sys::g_param_spec_set_qdata_full() }
87    //}
88
89    //pub fn steal_qdata(&self, quark: /*Ignored*/glib::Quark) -> /*Unimplemented*/Option<Fundamental: Pointer> {
90    //    unsafe { TODO: call gobject_sys::g_param_spec_steal_qdata() }
91    //}
92
93    pub fn boolean(
94        name: &str,
95        nick: &str,
96        blurb: &str,
97        default_value: bool,
98        flags: ParamFlags,
99    ) -> ParamSpec {
100        unsafe {
101            from_glib_full(gobject_sys::g_param_spec_boolean(
102                name.to_glib_none().0,
103                nick.to_glib_none().0,
104                blurb.to_glib_none().0,
105                default_value.to_glib(),
106                flags.to_glib(),
107            ))
108        }
109    }
110
111    pub fn boxed(
112        name: &str,
113        nick: &str,
114        blurb: &str,
115        boxed_type: ::Type,
116        flags: ParamFlags,
117    ) -> ParamSpec {
118        unsafe {
119            from_glib_full(gobject_sys::g_param_spec_boxed(
120                name.to_glib_none().0,
121                nick.to_glib_none().0,
122                blurb.to_glib_none().0,
123                boxed_type.to_glib(),
124                flags.to_glib(),
125            ))
126        }
127    }
128
129    pub fn char(
130        name: &str,
131        nick: &str,
132        blurb: &str,
133        minimum: i8,
134        maximum: i8,
135        default_value: i8,
136        flags: ParamFlags,
137    ) -> ParamSpec {
138        unsafe {
139            from_glib_full(gobject_sys::g_param_spec_char(
140                name.to_glib_none().0,
141                nick.to_glib_none().0,
142                blurb.to_glib_none().0,
143                minimum,
144                maximum,
145                default_value,
146                flags.to_glib(),
147            ))
148        }
149    }
150
151    pub fn double(
152        name: &str,
153        nick: &str,
154        blurb: &str,
155        minimum: f64,
156        maximum: f64,
157        default_value: f64,
158        flags: ParamFlags,
159    ) -> ParamSpec {
160        unsafe {
161            from_glib_full(gobject_sys::g_param_spec_double(
162                name.to_glib_none().0,
163                nick.to_glib_none().0,
164                blurb.to_glib_none().0,
165                minimum,
166                maximum,
167                default_value,
168                flags.to_glib(),
169            ))
170        }
171    }
172
173    pub fn enum_(
174        name: &str,
175        nick: &str,
176        blurb: &str,
177        enum_type: ::Type,
178        default_value: i32,
179        flags: ParamFlags,
180    ) -> ParamSpec {
181        unsafe {
182            from_glib_full(gobject_sys::g_param_spec_enum(
183                name.to_glib_none().0,
184                nick.to_glib_none().0,
185                blurb.to_glib_none().0,
186                enum_type.to_glib(),
187                default_value,
188                flags.to_glib(),
189            ))
190        }
191    }
192
193    pub fn flags(
194        name: &str,
195        nick: &str,
196        blurb: &str,
197        flags_type: ::Type,
198        default_value: u32,
199        flags: ParamFlags,
200    ) -> ParamSpec {
201        unsafe {
202            from_glib_full(gobject_sys::g_param_spec_flags(
203                name.to_glib_none().0,
204                nick.to_glib_none().0,
205                blurb.to_glib_none().0,
206                flags_type.to_glib(),
207                default_value,
208                flags.to_glib(),
209            ))
210        }
211    }
212
213    pub fn float(
214        name: &str,
215        nick: &str,
216        blurb: &str,
217        minimum: f32,
218        maximum: f32,
219        default_value: f32,
220        flags: ParamFlags,
221    ) -> ParamSpec {
222        unsafe {
223            from_glib_full(gobject_sys::g_param_spec_float(
224                name.to_glib_none().0,
225                nick.to_glib_none().0,
226                blurb.to_glib_none().0,
227                minimum,
228                maximum,
229                default_value,
230                flags.to_glib(),
231            ))
232        }
233    }
234
235    pub fn gtype(
236        name: &str,
237        nick: &str,
238        blurb: &str,
239        is_a_type: ::Type,
240        flags: ParamFlags,
241    ) -> ParamSpec {
242        unsafe {
243            from_glib_full(gobject_sys::g_param_spec_gtype(
244                name.to_glib_none().0,
245                nick.to_glib_none().0,
246                blurb.to_glib_none().0,
247                is_a_type.to_glib(),
248                flags.to_glib(),
249            ))
250        }
251    }
252
253    pub fn int(
254        name: &str,
255        nick: &str,
256        blurb: &str,
257        minimum: i32,
258        maximum: i32,
259        default_value: i32,
260        flags: ParamFlags,
261    ) -> ParamSpec {
262        unsafe {
263            from_glib_full(gobject_sys::g_param_spec_int(
264                name.to_glib_none().0,
265                nick.to_glib_none().0,
266                blurb.to_glib_none().0,
267                minimum,
268                maximum,
269                default_value,
270                flags.to_glib(),
271            ))
272        }
273    }
274
275    pub fn int64(
276        name: &str,
277        nick: &str,
278        blurb: &str,
279        minimum: i64,
280        maximum: i64,
281        default_value: i64,
282        flags: ParamFlags,
283    ) -> ParamSpec {
284        unsafe {
285            from_glib_full(gobject_sys::g_param_spec_int64(
286                name.to_glib_none().0,
287                nick.to_glib_none().0,
288                blurb.to_glib_none().0,
289                minimum,
290                maximum,
291                default_value,
292                flags.to_glib(),
293            ))
294        }
295    }
296
297    pub fn long(
298        name: &str,
299        nick: &str,
300        blurb: &str,
301        minimum: libc::c_long,
302        maximum: libc::c_long,
303        default_value: libc::c_long,
304        flags: ParamFlags,
305    ) -> ParamSpec {
306        unsafe {
307            from_glib_full(gobject_sys::g_param_spec_long(
308                name.to_glib_none().0,
309                nick.to_glib_none().0,
310                blurb.to_glib_none().0,
311                minimum,
312                maximum,
313                default_value,
314                flags.to_glib(),
315            ))
316        }
317    }
318
319    pub fn object(
320        name: &str,
321        nick: &str,
322        blurb: &str,
323        object_type: ::Type,
324        flags: ParamFlags,
325    ) -> ParamSpec {
326        unsafe {
327            from_glib_full(gobject_sys::g_param_spec_object(
328                name.to_glib_none().0,
329                nick.to_glib_none().0,
330                blurb.to_glib_none().0,
331                object_type.to_glib(),
332                flags.to_glib(),
333            ))
334        }
335    }
336
337    pub fn override_(name: &str, overridden: &ParamSpec) -> ParamSpec {
338        unsafe {
339            from_glib_none(gobject_sys::g_param_spec_override(
340                name.to_glib_none().0,
341                overridden.to_glib_none().0,
342            ))
343        }
344    }
345
346    pub fn param(
347        name: &str,
348        nick: &str,
349        blurb: &str,
350        param_type: ::Type,
351        flags: ParamFlags,
352    ) -> ParamSpec {
353        unsafe {
354            from_glib_full(gobject_sys::g_param_spec_param(
355                name.to_glib_none().0,
356                nick.to_glib_none().0,
357                blurb.to_glib_none().0,
358                param_type.to_glib(),
359                flags.to_glib(),
360            ))
361        }
362    }
363
364    pub fn pointer(name: &str, nick: &str, blurb: &str, flags: ParamFlags) -> ParamSpec {
365        unsafe {
366            from_glib_full(gobject_sys::g_param_spec_pointer(
367                name.to_glib_none().0,
368                nick.to_glib_none().0,
369                blurb.to_glib_none().0,
370                flags.to_glib(),
371            ))
372        }
373    }
374
375    pub fn string(
376        name: &str,
377        nick: &str,
378        blurb: &str,
379        default_value: Option<&str>,
380        flags: ParamFlags,
381    ) -> ParamSpec {
382        let default_value = default_value.to_glib_none();
383        unsafe {
384            from_glib_full(gobject_sys::g_param_spec_string(
385                name.to_glib_none().0,
386                nick.to_glib_none().0,
387                blurb.to_glib_none().0,
388                default_value.0,
389                flags.to_glib(),
390            ))
391        }
392    }
393
394    pub fn uchar(
395        name: &str,
396        nick: &str,
397        blurb: &str,
398        minimum: u8,
399        maximum: u8,
400        default_value: u8,
401        flags: ParamFlags,
402    ) -> ParamSpec {
403        unsafe {
404            from_glib_full(gobject_sys::g_param_spec_uchar(
405                name.to_glib_none().0,
406                nick.to_glib_none().0,
407                blurb.to_glib_none().0,
408                minimum,
409                maximum,
410                default_value,
411                flags.to_glib(),
412            ))
413        }
414    }
415
416    pub fn uint(
417        name: &str,
418        nick: &str,
419        blurb: &str,
420        minimum: u32,
421        maximum: u32,
422        default_value: u32,
423        flags: ParamFlags,
424    ) -> ParamSpec {
425        unsafe {
426            from_glib_full(gobject_sys::g_param_spec_uint(
427                name.to_glib_none().0,
428                nick.to_glib_none().0,
429                blurb.to_glib_none().0,
430                minimum,
431                maximum,
432                default_value,
433                flags.to_glib(),
434            ))
435        }
436    }
437
438    pub fn uint64(
439        name: &str,
440        nick: &str,
441        blurb: &str,
442        minimum: u64,
443        maximum: u64,
444        default_value: u64,
445        flags: ParamFlags,
446    ) -> ParamSpec {
447        unsafe {
448            from_glib_full(gobject_sys::g_param_spec_uint64(
449                name.to_glib_none().0,
450                nick.to_glib_none().0,
451                blurb.to_glib_none().0,
452                minimum,
453                maximum,
454                default_value,
455                flags.to_glib(),
456            ))
457        }
458    }
459
460    pub fn ulong(
461        name: &str,
462        nick: &str,
463        blurb: &str,
464        minimum: libc::c_ulong,
465        maximum: libc::c_ulong,
466        default_value: libc::c_ulong,
467        flags: ParamFlags,
468    ) -> ParamSpec {
469        unsafe {
470            from_glib_full(gobject_sys::g_param_spec_ulong(
471                name.to_glib_none().0,
472                nick.to_glib_none().0,
473                blurb.to_glib_none().0,
474                minimum,
475                maximum,
476                default_value,
477                flags.to_glib(),
478            ))
479        }
480    }
481
482    pub fn unichar(
483        name: &str,
484        nick: &str,
485        blurb: &str,
486        default_value: char,
487        flags: ParamFlags,
488    ) -> ParamSpec {
489        unsafe {
490            from_glib_full(gobject_sys::g_param_spec_unichar(
491                name.to_glib_none().0,
492                nick.to_glib_none().0,
493                blurb.to_glib_none().0,
494                default_value.to_glib(),
495                flags.to_glib(),
496            ))
497        }
498    }
499
500    pub fn value_array(
501        name: &str,
502        nick: &str,
503        blurb: &str,
504        element_spec: &ParamSpec,
505        flags: ParamFlags,
506    ) -> ParamSpec {
507        unsafe {
508            from_glib_none(gobject_sys::g_param_spec_value_array(
509                name.to_glib_none().0,
510                nick.to_glib_none().0,
511                blurb.to_glib_none().0,
512                element_spec.to_glib_none().0,
513                flags.to_glib(),
514            ))
515        }
516    }
517
518    pub fn variant(
519        name: &str,
520        nick: &str,
521        blurb: &str,
522        type_: &::VariantTy,
523        default_value: Option<&::Variant>,
524        flags: ParamFlags,
525    ) -> ParamSpec {
526        unsafe {
527            from_glib_none(gobject_sys::g_param_spec_variant(
528                name.to_glib_none().0,
529                nick.to_glib_none().0,
530                blurb.to_glib_none().0,
531                type_.to_glib_none().0,
532                default_value.to_glib_none().0,
533                flags.to_glib(),
534            ))
535        }
536    }
537}