1use cairo;
6use gdk;
7use gdk_pixbuf;
8use glib;
9use glib::object::IsA;
10use glib::translate::*;
11use glib::GString;
12use gtk_sys;
13use pango;
14use std::boxed::Box as Box_;
15use std::mem;
16use std::ptr;
17use AccelGroup;
18use Error;
19use Orientation;
20use PageSetup;
21use PositionType;
22use PrintSettings;
23use SelectionData;
24use SpinButton;
25use StyleContext;
26use TextBuffer;
27use TextDirection;
28use TreeModel;
29use TreePath;
30use Widget;
31use Window;
32
33pub fn accel_groups_activate<P: IsA<glib::Object>>(
34 object: &P,
35 accel_key: u32,
36 accel_mods: gdk::ModifierType,
37) -> bool {
38 assert_initialized_main_thread!();
39 unsafe {
40 from_glib(gtk_sys::gtk_accel_groups_activate(
41 object.as_ref().to_glib_none().0,
42 accel_key,
43 accel_mods.to_glib(),
44 ))
45 }
46}
47
48pub fn accel_groups_from_object<P: IsA<glib::Object>>(object: &P) -> Vec<AccelGroup> {
49 assert_initialized_main_thread!();
50 unsafe {
51 FromGlibPtrContainer::from_glib_none(gtk_sys::gtk_accel_groups_from_object(
52 object.as_ref().to_glib_none().0,
53 ))
54 }
55}
56
57pub fn accelerator_get_default_mod_mask() -> gdk::ModifierType {
58 assert_initialized_main_thread!();
59 unsafe { from_glib(gtk_sys::gtk_accelerator_get_default_mod_mask()) }
60}
61
62pub fn accelerator_get_label(
63 accelerator_key: u32,
64 accelerator_mods: gdk::ModifierType,
65) -> Option<GString> {
66 assert_initialized_main_thread!();
67 unsafe {
68 from_glib_full(gtk_sys::gtk_accelerator_get_label(
69 accelerator_key,
70 accelerator_mods.to_glib(),
71 ))
72 }
73}
74
75pub fn accelerator_get_label_with_keycode(
76 display: Option<&gdk::Display>,
77 accelerator_key: u32,
78 keycode: u32,
79 accelerator_mods: gdk::ModifierType,
80) -> Option<GString> {
81 assert_initialized_main_thread!();
82 unsafe {
83 from_glib_full(gtk_sys::gtk_accelerator_get_label_with_keycode(
84 display.to_glib_none().0,
85 accelerator_key,
86 keycode,
87 accelerator_mods.to_glib(),
88 ))
89 }
90}
91
92pub fn accelerator_name(
93 accelerator_key: u32,
94 accelerator_mods: gdk::ModifierType,
95) -> Option<GString> {
96 assert_initialized_main_thread!();
97 unsafe {
98 from_glib_full(gtk_sys::gtk_accelerator_name(
99 accelerator_key,
100 accelerator_mods.to_glib(),
101 ))
102 }
103}
104
105pub fn accelerator_name_with_keycode(
106 display: Option<&gdk::Display>,
107 accelerator_key: u32,
108 keycode: u32,
109 accelerator_mods: gdk::ModifierType,
110) -> Option<GString> {
111 assert_initialized_main_thread!();
112 unsafe {
113 from_glib_full(gtk_sys::gtk_accelerator_name_with_keycode(
114 display.to_glib_none().0,
115 accelerator_key,
116 keycode,
117 accelerator_mods.to_glib(),
118 ))
119 }
120}
121
122pub fn accelerator_parse(accelerator: &str) -> (u32, gdk::ModifierType) {
123 assert_initialized_main_thread!();
124 unsafe {
125 let mut accelerator_key = mem::uninitialized();
126 let mut accelerator_mods = mem::uninitialized();
127 gtk_sys::gtk_accelerator_parse(
128 accelerator.to_glib_none().0,
129 &mut accelerator_key,
130 &mut accelerator_mods,
131 );
132 (accelerator_key, from_glib(accelerator_mods))
133 }
134}
135
136pub fn accelerator_set_default_mod_mask(default_mod_mask: gdk::ModifierType) {
141 assert_initialized_main_thread!();
142 unsafe {
143 gtk_sys::gtk_accelerator_set_default_mod_mask(default_mod_mask.to_glib());
144 }
145}
146
147pub fn accelerator_valid(keyval: u32, modifiers: gdk::ModifierType) -> bool {
148 assert_initialized_main_thread!();
149 unsafe { from_glib(gtk_sys::gtk_accelerator_valid(keyval, modifiers.to_glib())) }
150}
151
152pub fn bindings_activate<P: IsA<glib::Object>>(
153 object: &P,
154 keyval: u32,
155 modifiers: gdk::ModifierType,
156) -> bool {
157 assert_initialized_main_thread!();
158 unsafe {
159 from_glib(gtk_sys::gtk_bindings_activate(
160 object.as_ref().to_glib_none().0,
161 keyval,
162 modifiers.to_glib(),
163 ))
164 }
165}
166
167pub fn bindings_activate_event<P: IsA<glib::Object>>(
168 object: &P,
169 event: &mut gdk::EventKey,
170) -> bool {
171 assert_initialized_main_thread!();
172 unsafe {
173 from_glib(gtk_sys::gtk_bindings_activate_event(
174 object.as_ref().to_glib_none().0,
175 event.to_glib_none_mut().0,
176 ))
177 }
178}
179
180pub fn cairo_should_draw_window<P: IsA<gdk::Window>>(cr: &cairo::Context, window: &P) -> bool {
181 assert_initialized_main_thread!();
182 unsafe {
183 from_glib(gtk_sys::gtk_cairo_should_draw_window(
184 mut_override(cr.to_glib_none().0),
185 window.as_ref().to_glib_none().0,
186 ))
187 }
188}
189
190pub fn cairo_transform_to_window<P: IsA<Widget>, Q: IsA<gdk::Window>>(
191 cr: &cairo::Context,
192 widget: &P,
193 window: &Q,
194) {
195 skip_assert_initialized!();
196 unsafe {
197 gtk_sys::gtk_cairo_transform_to_window(
198 mut_override(cr.to_glib_none().0),
199 widget.as_ref().to_glib_none().0,
200 window.as_ref().to_glib_none().0,
201 );
202 }
203}
204
205pub fn device_grab_add<P: IsA<Widget>>(widget: &P, device: &gdk::Device, block_others: bool) {
206 skip_assert_initialized!();
207 unsafe {
208 gtk_sys::gtk_device_grab_add(
209 widget.as_ref().to_glib_none().0,
210 device.to_glib_none().0,
211 block_others.to_glib(),
212 );
213 }
214}
215
216pub fn device_grab_remove<P: IsA<Widget>>(widget: &P, device: &gdk::Device) {
217 skip_assert_initialized!();
218 unsafe {
219 gtk_sys::gtk_device_grab_remove(widget.as_ref().to_glib_none().0, device.to_glib_none().0);
220 }
221}
222
223pub fn disable_setlocale() {
224 assert_initialized_main_thread!();
225 unsafe {
226 gtk_sys::gtk_disable_setlocale();
227 }
228}
229
230pub fn events_pending() -> bool {
235 assert_initialized_main_thread!();
236 unsafe { from_glib(gtk_sys::gtk_events_pending()) }
237}
238
239pub fn false_() -> bool {
240 assert_initialized_main_thread!();
241 unsafe { from_glib(gtk_sys::gtk_false()) }
242}
243
244pub fn get_current_event() -> Option<gdk::Event> {
245 assert_initialized_main_thread!();
246 unsafe { from_glib_full(gtk_sys::gtk_get_current_event()) }
247}
248
249pub fn get_current_event_device() -> Option<gdk::Device> {
250 assert_initialized_main_thread!();
251 unsafe { from_glib_none(gtk_sys::gtk_get_current_event_device()) }
252}
253
254pub fn get_current_event_state() -> Option<gdk::ModifierType> {
255 assert_initialized_main_thread!();
256 unsafe {
257 let mut state = mem::uninitialized();
258 let ret = from_glib(gtk_sys::gtk_get_current_event_state(&mut state));
259 if ret {
260 Some(from_glib(state))
261 } else {
262 None
263 }
264 }
265}
266
267pub fn get_current_event_time() -> u32 {
268 assert_initialized_main_thread!();
269 unsafe { gtk_sys::gtk_get_current_event_time() }
270}
271
272pub fn get_debug_flags() -> u32 {
273 assert_initialized_main_thread!();
274 unsafe { gtk_sys::gtk_get_debug_flags() }
275}
276
277pub fn get_default_language() -> Option<pango::Language> {
278 assert_initialized_main_thread!();
279 unsafe { from_glib_none(gtk_sys::gtk_get_default_language()) }
280}
281
282pub fn get_event_widget(event: &mut gdk::Event) -> Option<Widget> {
283 assert_initialized_main_thread!();
284 unsafe { from_glib_none(gtk_sys::gtk_get_event_widget(event.to_glib_none_mut().0)) }
285}
286
287pub fn get_locale_direction() -> TextDirection {
288 assert_initialized_main_thread!();
289 unsafe { from_glib(gtk_sys::gtk_get_locale_direction()) }
290}
291
292pub fn grab_get_current() -> Option<Widget> {
297 assert_initialized_main_thread!();
298 unsafe { from_glib_none(gtk_sys::gtk_grab_get_current()) }
299}
300
301pub fn main() {
310 assert_initialized_main_thread!();
311 unsafe {
312 gtk_sys::gtk_main();
313 }
314}
315
316pub fn main_do_event(event: &mut gdk::Event) {
317 assert_initialized_main_thread!();
318 unsafe {
319 gtk_sys::gtk_main_do_event(event.to_glib_none_mut().0);
320 }
321}
322
323pub fn main_iteration() -> bool {
324 assert_initialized_main_thread!();
325 unsafe { from_glib(gtk_sys::gtk_main_iteration()) }
326}
327
328pub fn main_iteration_do(blocking: bool) -> bool {
329 assert_initialized_main_thread!();
330 unsafe { from_glib(gtk_sys::gtk_main_iteration_do(blocking.to_glib())) }
331}
332
333pub fn main_level() -> u32 {
334 assert_initialized_main_thread!();
335 unsafe { gtk_sys::gtk_main_level() }
336}
337
338pub fn print_run_page_setup_dialog<P: IsA<Window>>(
343 parent: Option<&P>,
344 page_setup: Option<&PageSetup>,
345 settings: &PrintSettings,
346) -> Option<PageSetup> {
347 skip_assert_initialized!();
348 unsafe {
349 from_glib_full(gtk_sys::gtk_print_run_page_setup_dialog(
350 parent.map(|p| p.as_ref()).to_glib_none().0,
351 page_setup.to_glib_none().0,
352 settings.to_glib_none().0,
353 ))
354 }
355}
356
357pub fn print_run_page_setup_dialog_async<
358 P: IsA<Window>,
359 Q: FnOnce(&PageSetup) + Send + Sync + 'static,
360>(
361 parent: Option<&P>,
362 page_setup: Option<&PageSetup>,
363 settings: &PrintSettings,
364 done_cb: Q,
365) {
366 skip_assert_initialized!();
367 let done_cb_data: Box_<Q> = Box::new(done_cb);
368 unsafe extern "C" fn done_cb_func<
369 P: IsA<Window>,
370 Q: FnOnce(&PageSetup) + Send + Sync + 'static,
371 >(
372 page_setup: *mut gtk_sys::GtkPageSetup,
373 data: glib_sys::gpointer,
374 ) {
375 let page_setup = from_glib_borrow(page_setup);
376 let callback: Box_<Q> = Box_::from_raw(data as *mut _);
377 (*callback)(&page_setup);
378 }
379 let done_cb = Some(done_cb_func::<P, Q> as _);
380 let super_callback0: Box_<Q> = done_cb_data;
381 unsafe {
382 gtk_sys::gtk_print_run_page_setup_dialog_async(
383 parent.map(|p| p.as_ref()).to_glib_none().0,
384 page_setup.to_glib_none().0,
385 settings.to_glib_none().0,
386 done_cb,
387 Box::into_raw(super_callback0) as *mut _,
388 );
389 }
390}
391
392pub fn propagate_event<P: IsA<Widget>>(widget: &P, event: &mut gdk::Event) {
393 skip_assert_initialized!();
394 unsafe {
395 gtk_sys::gtk_propagate_event(widget.as_ref().to_glib_none().0, event.to_glib_none_mut().0);
396 }
397}
398
399pub fn render_activity<P: IsA<StyleContext>>(
400 context: &P,
401 cr: &cairo::Context,
402 x: f64,
403 y: f64,
404 width: f64,
405 height: f64,
406) {
407 skip_assert_initialized!();
408 unsafe {
409 gtk_sys::gtk_render_activity(
410 context.as_ref().to_glib_none().0,
411 mut_override(cr.to_glib_none().0),
412 x,
413 y,
414 width,
415 height,
416 );
417 }
418}
419
420pub fn render_arrow<P: IsA<StyleContext>>(
421 context: &P,
422 cr: &cairo::Context,
423 angle: f64,
424 x: f64,
425 y: f64,
426 size: f64,
427) {
428 skip_assert_initialized!();
429 unsafe {
430 gtk_sys::gtk_render_arrow(
431 context.as_ref().to_glib_none().0,
432 mut_override(cr.to_glib_none().0),
433 angle,
434 x,
435 y,
436 size,
437 );
438 }
439}
440
441pub fn render_background<P: IsA<StyleContext>>(
442 context: &P,
443 cr: &cairo::Context,
444 x: f64,
445 y: f64,
446 width: f64,
447 height: f64,
448) {
449 skip_assert_initialized!();
450 unsafe {
451 gtk_sys::gtk_render_background(
452 context.as_ref().to_glib_none().0,
453 mut_override(cr.to_glib_none().0),
454 x,
455 y,
456 width,
457 height,
458 );
459 }
460}
461
462#[cfg(any(feature = "v3_20", feature = "dox"))]
463pub fn render_background_get_clip<P: IsA<StyleContext>>(
464 context: &P,
465 x: f64,
466 y: f64,
467 width: f64,
468 height: f64,
469) -> gdk::Rectangle {
470 skip_assert_initialized!();
471 unsafe {
472 let mut out_clip = gdk::Rectangle::uninitialized();
473 gtk_sys::gtk_render_background_get_clip(
474 context.as_ref().to_glib_none().0,
475 x,
476 y,
477 width,
478 height,
479 out_clip.to_glib_none_mut().0,
480 );
481 out_clip
482 }
483}
484
485pub fn render_check<P: IsA<StyleContext>>(
486 context: &P,
487 cr: &cairo::Context,
488 x: f64,
489 y: f64,
490 width: f64,
491 height: f64,
492) {
493 skip_assert_initialized!();
494 unsafe {
495 gtk_sys::gtk_render_check(
496 context.as_ref().to_glib_none().0,
497 mut_override(cr.to_glib_none().0),
498 x,
499 y,
500 width,
501 height,
502 );
503 }
504}
505
506pub fn render_expander<P: IsA<StyleContext>>(
507 context: &P,
508 cr: &cairo::Context,
509 x: f64,
510 y: f64,
511 width: f64,
512 height: f64,
513) {
514 skip_assert_initialized!();
515 unsafe {
516 gtk_sys::gtk_render_expander(
517 context.as_ref().to_glib_none().0,
518 mut_override(cr.to_glib_none().0),
519 x,
520 y,
521 width,
522 height,
523 );
524 }
525}
526
527pub fn render_extension<P: IsA<StyleContext>>(
528 context: &P,
529 cr: &cairo::Context,
530 x: f64,
531 y: f64,
532 width: f64,
533 height: f64,
534 gap_side: PositionType,
535) {
536 skip_assert_initialized!();
537 unsafe {
538 gtk_sys::gtk_render_extension(
539 context.as_ref().to_glib_none().0,
540 mut_override(cr.to_glib_none().0),
541 x,
542 y,
543 width,
544 height,
545 gap_side.to_glib(),
546 );
547 }
548}
549
550pub fn render_focus<P: IsA<StyleContext>>(
551 context: &P,
552 cr: &cairo::Context,
553 x: f64,
554 y: f64,
555 width: f64,
556 height: f64,
557) {
558 skip_assert_initialized!();
559 unsafe {
560 gtk_sys::gtk_render_focus(
561 context.as_ref().to_glib_none().0,
562 mut_override(cr.to_glib_none().0),
563 x,
564 y,
565 width,
566 height,
567 );
568 }
569}
570
571pub fn render_frame<P: IsA<StyleContext>>(
572 context: &P,
573 cr: &cairo::Context,
574 x: f64,
575 y: f64,
576 width: f64,
577 height: f64,
578) {
579 skip_assert_initialized!();
580 unsafe {
581 gtk_sys::gtk_render_frame(
582 context.as_ref().to_glib_none().0,
583 mut_override(cr.to_glib_none().0),
584 x,
585 y,
586 width,
587 height,
588 );
589 }
590}
591
592#[cfg_attr(feature = "v3_24", deprecated)]
593pub fn render_frame_gap<P: IsA<StyleContext>>(
594 context: &P,
595 cr: &cairo::Context,
596 x: f64,
597 y: f64,
598 width: f64,
599 height: f64,
600 gap_side: PositionType,
601 xy0_gap: f64,
602 xy1_gap: f64,
603) {
604 skip_assert_initialized!();
605 unsafe {
606 gtk_sys::gtk_render_frame_gap(
607 context.as_ref().to_glib_none().0,
608 mut_override(cr.to_glib_none().0),
609 x,
610 y,
611 width,
612 height,
613 gap_side.to_glib(),
614 xy0_gap,
615 xy1_gap,
616 );
617 }
618}
619
620pub fn render_handle<P: IsA<StyleContext>>(
621 context: &P,
622 cr: &cairo::Context,
623 x: f64,
624 y: f64,
625 width: f64,
626 height: f64,
627) {
628 skip_assert_initialized!();
629 unsafe {
630 gtk_sys::gtk_render_handle(
631 context.as_ref().to_glib_none().0,
632 mut_override(cr.to_glib_none().0),
633 x,
634 y,
635 width,
636 height,
637 );
638 }
639}
640
641pub fn render_icon<P: IsA<StyleContext>>(
642 context: &P,
643 cr: &cairo::Context,
644 pixbuf: &gdk_pixbuf::Pixbuf,
645 x: f64,
646 y: f64,
647) {
648 skip_assert_initialized!();
649 unsafe {
650 gtk_sys::gtk_render_icon(
651 context.as_ref().to_glib_none().0,
652 mut_override(cr.to_glib_none().0),
653 pixbuf.to_glib_none().0,
654 x,
655 y,
656 );
657 }
658}
659
660pub fn render_icon_surface<P: IsA<StyleContext>>(
661 context: &P,
662 cr: &cairo::Context,
663 surface: &cairo::Surface,
664 x: f64,
665 y: f64,
666) {
667 skip_assert_initialized!();
668 unsafe {
669 gtk_sys::gtk_render_icon_surface(
670 context.as_ref().to_glib_none().0,
671 mut_override(cr.to_glib_none().0),
672 mut_override(surface.to_glib_none().0),
673 x,
674 y,
675 );
676 }
677}
678
679pub fn render_insertion_cursor<P: IsA<StyleContext>>(
680 context: &P,
681 cr: &cairo::Context,
682 x: f64,
683 y: f64,
684 layout: &pango::Layout,
685 index: i32,
686 direction: pango::Direction,
687) {
688 skip_assert_initialized!();
689 unsafe {
690 gtk_sys::gtk_render_insertion_cursor(
691 context.as_ref().to_glib_none().0,
692 mut_override(cr.to_glib_none().0),
693 x,
694 y,
695 layout.to_glib_none().0,
696 index,
697 direction.to_glib(),
698 );
699 }
700}
701
702pub fn render_layout<P: IsA<StyleContext>>(
703 context: &P,
704 cr: &cairo::Context,
705 x: f64,
706 y: f64,
707 layout: &pango::Layout,
708) {
709 skip_assert_initialized!();
710 unsafe {
711 gtk_sys::gtk_render_layout(
712 context.as_ref().to_glib_none().0,
713 mut_override(cr.to_glib_none().0),
714 x,
715 y,
716 layout.to_glib_none().0,
717 );
718 }
719}
720
721pub fn render_line<P: IsA<StyleContext>>(
722 context: &P,
723 cr: &cairo::Context,
724 x0: f64,
725 y0: f64,
726 x1: f64,
727 y1: f64,
728) {
729 skip_assert_initialized!();
730 unsafe {
731 gtk_sys::gtk_render_line(
732 context.as_ref().to_glib_none().0,
733 mut_override(cr.to_glib_none().0),
734 x0,
735 y0,
736 x1,
737 y1,
738 );
739 }
740}
741
742pub fn render_option<P: IsA<StyleContext>>(
743 context: &P,
744 cr: &cairo::Context,
745 x: f64,
746 y: f64,
747 width: f64,
748 height: f64,
749) {
750 skip_assert_initialized!();
751 unsafe {
752 gtk_sys::gtk_render_option(
753 context.as_ref().to_glib_none().0,
754 mut_override(cr.to_glib_none().0),
755 x,
756 y,
757 width,
758 height,
759 );
760 }
761}
762
763pub fn render_slider<P: IsA<StyleContext>>(
764 context: &P,
765 cr: &cairo::Context,
766 x: f64,
767 y: f64,
768 width: f64,
769 height: f64,
770 orientation: Orientation,
771) {
772 skip_assert_initialized!();
773 unsafe {
774 gtk_sys::gtk_render_slider(
775 context.as_ref().to_glib_none().0,
776 mut_override(cr.to_glib_none().0),
777 x,
778 y,
779 width,
780 height,
781 orientation.to_glib(),
782 );
783 }
784}
785
786pub fn rgb_to_hsv(r: f64, g: f64, b: f64) -> (f64, f64, f64) {
787 assert_initialized_main_thread!();
788 unsafe {
789 let mut h = mem::uninitialized();
790 let mut s = mem::uninitialized();
791 let mut v = mem::uninitialized();
792 gtk_sys::gtk_rgb_to_hsv(r, g, b, &mut h, &mut s, &mut v);
793 (h, s, v)
794 }
795}
796
797pub fn selection_add_target<P: IsA<Widget>>(
798 widget: &P,
799 selection: &gdk::Atom,
800 target: &gdk::Atom,
801 info: u32,
802) {
803 skip_assert_initialized!();
804 unsafe {
805 gtk_sys::gtk_selection_add_target(
806 widget.as_ref().to_glib_none().0,
807 selection.to_glib_none().0,
808 target.to_glib_none().0,
809 info,
810 );
811 }
812}
813
814pub fn selection_clear_targets<P: IsA<Widget>>(widget: &P, selection: &gdk::Atom) {
815 skip_assert_initialized!();
816 unsafe {
817 gtk_sys::gtk_selection_clear_targets(
818 widget.as_ref().to_glib_none().0,
819 selection.to_glib_none().0,
820 );
821 }
822}
823
824pub fn selection_convert<P: IsA<Widget>>(
825 widget: &P,
826 selection: &gdk::Atom,
827 target: &gdk::Atom,
828 time_: u32,
829) -> bool {
830 skip_assert_initialized!();
831 unsafe {
832 from_glib(gtk_sys::gtk_selection_convert(
833 widget.as_ref().to_glib_none().0,
834 selection.to_glib_none().0,
835 target.to_glib_none().0,
836 time_,
837 ))
838 }
839}
840
841pub fn selection_owner_set<P: IsA<Widget>>(
842 widget: Option<&P>,
843 selection: &gdk::Atom,
844 time_: u32,
845) -> bool {
846 assert_initialized_main_thread!();
847 unsafe {
848 from_glib(gtk_sys::gtk_selection_owner_set(
849 widget.map(|p| p.as_ref()).to_glib_none().0,
850 selection.to_glib_none().0,
851 time_,
852 ))
853 }
854}
855
856pub fn selection_owner_set_for_display<P: IsA<Widget>>(
857 display: &gdk::Display,
858 widget: Option<&P>,
859 selection: &gdk::Atom,
860 time_: u32,
861) -> bool {
862 assert_initialized_main_thread!();
863 unsafe {
864 from_glib(gtk_sys::gtk_selection_owner_set_for_display(
865 display.to_glib_none().0,
866 widget.map(|p| p.as_ref()).to_glib_none().0,
867 selection.to_glib_none().0,
868 time_,
869 ))
870 }
871}
872
873pub fn selection_remove_all<P: IsA<Widget>>(widget: &P) {
874 skip_assert_initialized!();
875 unsafe {
876 gtk_sys::gtk_selection_remove_all(widget.as_ref().to_glib_none().0);
877 }
878}
879
880pub fn set_debug_flags(flags: u32) {
881 assert_initialized_main_thread!();
882 unsafe {
883 gtk_sys::gtk_set_debug_flags(flags);
884 }
885}
886
887pub fn show_uri(screen: Option<&gdk::Screen>, uri: &str, timestamp: u32) -> Result<(), Error> {
892 assert_initialized_main_thread!();
893 unsafe {
894 let mut error = ptr::null_mut();
895 let _ = gtk_sys::gtk_show_uri(
896 screen.to_glib_none().0,
897 uri.to_glib_none().0,
898 timestamp,
899 &mut error,
900 );
901 if error.is_null() {
902 Ok(())
903 } else {
904 Err(from_glib_full(error))
905 }
906 }
907}
908
909#[cfg(any(feature = "v3_22", feature = "dox"))]
910pub fn show_uri_on_window<P: IsA<Window>>(
911 parent: Option<&P>,
912 uri: &str,
913 timestamp: u32,
914) -> Result<(), Error> {
915 assert_initialized_main_thread!();
916 unsafe {
917 let mut error = ptr::null_mut();
918 let _ = gtk_sys::gtk_show_uri_on_window(
919 parent.map(|p| p.as_ref()).to_glib_none().0,
920 uri.to_glib_none().0,
921 timestamp,
922 &mut error,
923 );
924 if error.is_null() {
925 Ok(())
926 } else {
927 Err(from_glib_full(error))
928 }
929 }
930}
931
932pub fn targets_include_image(targets: &[&gdk::Atom], writable: bool) -> bool {
933 assert_initialized_main_thread!();
934 let n_targets = targets.len() as i32;
935 unsafe {
936 from_glib(gtk_sys::gtk_targets_include_image(
937 targets.to_glib_none().0,
938 n_targets,
939 writable.to_glib(),
940 ))
941 }
942}
943
944pub fn targets_include_rich_text<P: IsA<TextBuffer>>(targets: &[&gdk::Atom], buffer: &P) -> bool {
945 skip_assert_initialized!();
946 let n_targets = targets.len() as i32;
947 unsafe {
948 from_glib(gtk_sys::gtk_targets_include_rich_text(
949 targets.to_glib_none().0,
950 n_targets,
951 buffer.as_ref().to_glib_none().0,
952 ))
953 }
954}
955
956pub fn targets_include_text(targets: &[&gdk::Atom]) -> bool {
957 assert_initialized_main_thread!();
958 let n_targets = targets.len() as i32;
959 unsafe {
960 from_glib(gtk_sys::gtk_targets_include_text(
961 targets.to_glib_none().0,
962 n_targets,
963 ))
964 }
965}
966
967pub fn targets_include_uri(targets: &[&gdk::Atom]) -> bool {
968 assert_initialized_main_thread!();
969 let n_targets = targets.len() as i32;
970 unsafe {
971 from_glib(gtk_sys::gtk_targets_include_uri(
972 targets.to_glib_none().0,
973 n_targets,
974 ))
975 }
976}
977
978#[cfg_attr(feature = "v3_20", deprecated)]
979pub fn test_create_simple_window(window_title: &str, dialog_text: &str) -> Option<Widget> {
980 assert_initialized_main_thread!();
981 unsafe {
982 from_glib_none(gtk_sys::gtk_test_create_simple_window(
983 window_title.to_glib_none().0,
984 dialog_text.to_glib_none().0,
985 ))
986 }
987}
988
989pub fn test_find_label<P: IsA<Widget>>(widget: &P, label_pattern: &str) -> Option<Widget> {
1000 skip_assert_initialized!();
1001 unsafe {
1002 from_glib_none(gtk_sys::gtk_test_find_label(
1003 widget.as_ref().to_glib_none().0,
1004 label_pattern.to_glib_none().0,
1005 ))
1006 }
1007}
1008
1009pub fn test_find_sibling<P: IsA<Widget>>(
1010 base_widget: &P,
1011 widget_type: glib::types::Type,
1012) -> Option<Widget> {
1013 skip_assert_initialized!();
1014 unsafe {
1015 from_glib_none(gtk_sys::gtk_test_find_sibling(
1016 base_widget.as_ref().to_glib_none().0,
1017 widget_type.to_glib(),
1018 ))
1019 }
1020}
1021
1022pub fn test_find_widget<P: IsA<Widget>>(
1023 widget: &P,
1024 label_pattern: &str,
1025 widget_type: glib::types::Type,
1026) -> Option<Widget> {
1027 skip_assert_initialized!();
1028 unsafe {
1029 from_glib_none(gtk_sys::gtk_test_find_widget(
1030 widget.as_ref().to_glib_none().0,
1031 label_pattern.to_glib_none().0,
1032 widget_type.to_glib(),
1033 ))
1034 }
1035}
1036
1037pub fn test_register_all_types() {
1046 assert_initialized_main_thread!();
1047 unsafe {
1048 gtk_sys::gtk_test_register_all_types();
1049 }
1050}
1051
1052#[cfg_attr(feature = "v3_20", deprecated)]
1053pub fn test_slider_get_value<P: IsA<Widget>>(widget: &P) -> f64 {
1054 skip_assert_initialized!();
1055 unsafe { gtk_sys::gtk_test_slider_get_value(widget.as_ref().to_glib_none().0) }
1056}
1057
1058#[cfg_attr(feature = "v3_20", deprecated)]
1059pub fn test_slider_set_perc<P: IsA<Widget>>(widget: &P, percentage: f64) {
1060 skip_assert_initialized!();
1061 unsafe {
1062 gtk_sys::gtk_test_slider_set_perc(widget.as_ref().to_glib_none().0, percentage);
1063 }
1064}
1065
1066#[cfg_attr(feature = "v3_20", deprecated)]
1067pub fn test_spin_button_click<P: IsA<SpinButton>>(spinner: &P, button: u32, upwards: bool) -> bool {
1068 skip_assert_initialized!();
1069 unsafe {
1070 from_glib(gtk_sys::gtk_test_spin_button_click(
1071 spinner.as_ref().to_glib_none().0,
1072 button,
1073 upwards.to_glib(),
1074 ))
1075 }
1076}
1077
1078#[cfg_attr(feature = "v3_20", deprecated)]
1079pub fn test_text_get<P: IsA<Widget>>(widget: &P) -> Option<GString> {
1080 skip_assert_initialized!();
1081 unsafe { from_glib_full(gtk_sys::gtk_test_text_get(widget.as_ref().to_glib_none().0)) }
1082}
1083
1084#[cfg_attr(feature = "v3_20", deprecated)]
1085pub fn test_text_set<P: IsA<Widget>>(widget: &P, string: &str) {
1086 skip_assert_initialized!();
1087 unsafe {
1088 gtk_sys::gtk_test_text_set(widget.as_ref().to_glib_none().0, string.to_glib_none().0);
1089 }
1090}
1091
1092#[cfg_attr(feature = "v3_20", deprecated)]
1093pub fn test_widget_click<P: IsA<Widget>>(
1094 widget: &P,
1095 button: u32,
1096 modifiers: gdk::ModifierType,
1097) -> bool {
1098 skip_assert_initialized!();
1099 unsafe {
1100 from_glib(gtk_sys::gtk_test_widget_click(
1101 widget.as_ref().to_glib_none().0,
1102 button,
1103 modifiers.to_glib(),
1104 ))
1105 }
1106}
1107
1108pub fn test_widget_send_key<P: IsA<Widget>>(
1109 widget: &P,
1110 keyval: u32,
1111 modifiers: gdk::ModifierType,
1112) -> bool {
1113 skip_assert_initialized!();
1114 unsafe {
1115 from_glib(gtk_sys::gtk_test_widget_send_key(
1116 widget.as_ref().to_glib_none().0,
1117 keyval,
1118 modifiers.to_glib(),
1119 ))
1120 }
1121}
1122
1123pub fn test_widget_wait_for_draw<P: IsA<Widget>>(widget: &P) {
1124 skip_assert_initialized!();
1125 unsafe {
1126 gtk_sys::gtk_test_widget_wait_for_draw(widget.as_ref().to_glib_none().0);
1127 }
1128}
1129
1130pub fn tree_get_row_drag_data(
1131 selection_data: &SelectionData,
1132) -> Option<(Option<TreeModel>, Option<TreePath>)> {
1133 assert_initialized_main_thread!();
1134 unsafe {
1135 let mut tree_model = ptr::null_mut();
1136 let mut path = ptr::null_mut();
1137 let ret = from_glib(gtk_sys::gtk_tree_get_row_drag_data(
1138 mut_override(selection_data.to_glib_none().0),
1139 &mut tree_model,
1140 &mut path,
1141 ));
1142 if ret {
1143 Some((from_glib_none(tree_model), from_glib_full(path)))
1144 } else {
1145 None
1146 }
1147 }
1148}
1149
1150pub fn tree_set_row_drag_data<P: IsA<TreeModel>>(
1151 selection_data: &SelectionData,
1152 tree_model: &P,
1153 path: &mut TreePath,
1154) -> bool {
1155 skip_assert_initialized!();
1156 unsafe {
1157 from_glib(gtk_sys::gtk_tree_set_row_drag_data(
1158 mut_override(selection_data.to_glib_none().0),
1159 tree_model.as_ref().to_glib_none().0,
1160 path.to_glib_none_mut().0,
1161 ))
1162 }
1163}
1164
1165pub fn true_() -> bool {
1166 assert_initialized_main_thread!();
1167 unsafe { from_glib(gtk_sys::gtk_true()) }
1168}