gtk/auto/
entry.rs

1// This file was generated by gir (https://github.com/gtk-rs/gir)
2// from gir-files (https://github.com/gtk-rs/gir-files)
3// DO NOT EDIT
4
5use gdk;
6use gdk_pixbuf;
7use gdk_sys;
8use gio;
9use glib;
10use glib::object::Cast;
11use glib::object::IsA;
12use glib::object::ObjectExt;
13use glib::signal::connect_raw;
14use glib::signal::SignalHandlerId;
15use glib::translate::*;
16use glib::GString;
17use glib::StaticType;
18use glib::ToValue;
19use glib::Value;
20use glib_sys;
21use gobject_sys;
22use gtk_sys;
23use libc;
24use pango;
25use std::boxed::Box as Box_;
26use std::fmt;
27use std::mem;
28use std::mem::transmute;
29use Adjustment;
30use Align;
31use Buildable;
32use CellEditable;
33use Container;
34use DeleteType;
35use Editable;
36use EntryBuffer;
37use EntryCompletion;
38use EntryIconPosition;
39use ImageType;
40use InputHints;
41use InputPurpose;
42use MovementStep;
43use ShadowType;
44use TargetList;
45use Widget;
46
47glib_wrapper! {
48    pub struct Entry(Object<gtk_sys::GtkEntry, gtk_sys::GtkEntryClass, EntryClass>) @extends Widget, @implements Buildable, CellEditable, Editable;
49
50    match fn {
51        get_type => || gtk_sys::gtk_entry_get_type(),
52    }
53}
54
55impl Entry {
56    pub fn new() -> Entry {
57        assert_initialized_main_thread!();
58        unsafe { Widget::from_glib_none(gtk_sys::gtk_entry_new()).unsafe_cast() }
59    }
60
61    pub fn new_with_buffer<P: IsA<EntryBuffer>>(buffer: &P) -> Entry {
62        skip_assert_initialized!();
63        unsafe {
64            Widget::from_glib_none(gtk_sys::gtk_entry_new_with_buffer(
65                buffer.as_ref().to_glib_none().0,
66            ))
67            .unsafe_cast()
68        }
69    }
70}
71
72impl Default for Entry {
73    fn default() -> Self {
74        Self::new()
75    }
76}
77
78pub struct EntryBuilder {
79    activates_default: Option<bool>,
80    attributes: Option<pango::AttrList>,
81    buffer: Option<EntryBuffer>,
82    caps_lock_warning: Option<bool>,
83    completion: Option<EntryCompletion>,
84    editable: Option<bool>,
85    enable_emoji_completion: Option<bool>,
86    has_frame: Option<bool>,
87    im_module: Option<String>,
88    input_hints: Option<InputHints>,
89    input_purpose: Option<InputPurpose>,
90    invisible_char: Option<u32>,
91    invisible_char_set: Option<bool>,
92    max_length: Option<i32>,
93    max_width_chars: Option<i32>,
94    overwrite_mode: Option<bool>,
95    placeholder_text: Option<String>,
96    populate_all: Option<bool>,
97    primary_icon_activatable: Option<bool>,
98    primary_icon_gicon: Option<gio::Icon>,
99    primary_icon_name: Option<String>,
100    primary_icon_pixbuf: Option<gdk_pixbuf::Pixbuf>,
101    primary_icon_sensitive: Option<bool>,
102    primary_icon_tooltip_markup: Option<String>,
103    primary_icon_tooltip_text: Option<String>,
104    progress_fraction: Option<f64>,
105    progress_pulse_step: Option<f64>,
106    secondary_icon_activatable: Option<bool>,
107    secondary_icon_gicon: Option<gio::Icon>,
108    secondary_icon_name: Option<String>,
109    secondary_icon_pixbuf: Option<gdk_pixbuf::Pixbuf>,
110    secondary_icon_sensitive: Option<bool>,
111    secondary_icon_tooltip_markup: Option<String>,
112    secondary_icon_tooltip_text: Option<String>,
113    shadow_type: Option<ShadowType>,
114    show_emoji_icon: Option<bool>,
115    text: Option<String>,
116    truncate_multiline: Option<bool>,
117    visibility: Option<bool>,
118    width_chars: Option<i32>,
119    xalign: Option<f32>,
120    app_paintable: Option<bool>,
121    can_default: Option<bool>,
122    can_focus: Option<bool>,
123    events: Option<gdk::EventMask>,
124    expand: Option<bool>,
125    #[cfg(any(feature = "v3_20", feature = "dox"))]
126    focus_on_click: Option<bool>,
127    halign: Option<Align>,
128    has_default: Option<bool>,
129    has_focus: Option<bool>,
130    has_tooltip: Option<bool>,
131    height_request: Option<i32>,
132    hexpand: Option<bool>,
133    hexpand_set: Option<bool>,
134    is_focus: Option<bool>,
135    margin: Option<i32>,
136    margin_bottom: Option<i32>,
137    margin_end: Option<i32>,
138    margin_start: Option<i32>,
139    margin_top: Option<i32>,
140    name: Option<String>,
141    no_show_all: Option<bool>,
142    opacity: Option<f64>,
143    parent: Option<Container>,
144    receives_default: Option<bool>,
145    sensitive: Option<bool>,
146    //style: /*Unknown type*/,
147    tooltip_markup: Option<String>,
148    tooltip_text: Option<String>,
149    valign: Option<Align>,
150    vexpand: Option<bool>,
151    vexpand_set: Option<bool>,
152    visible: Option<bool>,
153    width_request: Option<i32>,
154}
155
156impl EntryBuilder {
157    pub fn new() -> Self {
158        Self {
159            activates_default: None,
160            attributes: None,
161            buffer: None,
162            caps_lock_warning: None,
163            completion: None,
164            editable: None,
165            enable_emoji_completion: None,
166            has_frame: None,
167            im_module: None,
168            input_hints: None,
169            input_purpose: None,
170            invisible_char: None,
171            invisible_char_set: None,
172            max_length: None,
173            max_width_chars: None,
174            overwrite_mode: None,
175            placeholder_text: None,
176            populate_all: None,
177            primary_icon_activatable: None,
178            primary_icon_gicon: None,
179            primary_icon_name: None,
180            primary_icon_pixbuf: None,
181            primary_icon_sensitive: None,
182            primary_icon_tooltip_markup: None,
183            primary_icon_tooltip_text: None,
184            progress_fraction: None,
185            progress_pulse_step: None,
186            secondary_icon_activatable: None,
187            secondary_icon_gicon: None,
188            secondary_icon_name: None,
189            secondary_icon_pixbuf: None,
190            secondary_icon_sensitive: None,
191            secondary_icon_tooltip_markup: None,
192            secondary_icon_tooltip_text: None,
193            shadow_type: None,
194            show_emoji_icon: None,
195            text: None,
196            truncate_multiline: None,
197            visibility: None,
198            width_chars: None,
199            xalign: None,
200            app_paintable: None,
201            can_default: None,
202            can_focus: None,
203            events: None,
204            expand: None,
205            #[cfg(any(feature = "v3_20", feature = "dox"))]
206            focus_on_click: None,
207            halign: None,
208            has_default: None,
209            has_focus: None,
210            has_tooltip: None,
211            height_request: None,
212            hexpand: None,
213            hexpand_set: None,
214            is_focus: None,
215            margin: None,
216            margin_bottom: None,
217            margin_end: None,
218            margin_start: None,
219            margin_top: None,
220            name: None,
221            no_show_all: None,
222            opacity: None,
223            parent: None,
224            receives_default: None,
225            sensitive: None,
226            tooltip_markup: None,
227            tooltip_text: None,
228            valign: None,
229            vexpand: None,
230            vexpand_set: None,
231            visible: None,
232            width_request: None,
233        }
234    }
235
236    pub fn build(self) -> Entry {
237        let mut properties: Vec<(&str, &dyn ToValue)> = vec![];
238        if let Some(ref activates_default) = self.activates_default {
239            properties.push(("activates-default", activates_default));
240        }
241        if let Some(ref attributes) = self.attributes {
242            properties.push(("attributes", attributes));
243        }
244        if let Some(ref buffer) = self.buffer {
245            properties.push(("buffer", buffer));
246        }
247        if let Some(ref caps_lock_warning) = self.caps_lock_warning {
248            properties.push(("caps-lock-warning", caps_lock_warning));
249        }
250        if let Some(ref completion) = self.completion {
251            properties.push(("completion", completion));
252        }
253        if let Some(ref editable) = self.editable {
254            properties.push(("editable", editable));
255        }
256        if let Some(ref enable_emoji_completion) = self.enable_emoji_completion {
257            properties.push(("enable-emoji-completion", enable_emoji_completion));
258        }
259        if let Some(ref has_frame) = self.has_frame {
260            properties.push(("has-frame", has_frame));
261        }
262        if let Some(ref im_module) = self.im_module {
263            properties.push(("im-module", im_module));
264        }
265        if let Some(ref input_hints) = self.input_hints {
266            properties.push(("input-hints", input_hints));
267        }
268        if let Some(ref input_purpose) = self.input_purpose {
269            properties.push(("input-purpose", input_purpose));
270        }
271        if let Some(ref invisible_char) = self.invisible_char {
272            properties.push(("invisible-char", invisible_char));
273        }
274        if let Some(ref invisible_char_set) = self.invisible_char_set {
275            properties.push(("invisible-char-set", invisible_char_set));
276        }
277        if let Some(ref max_length) = self.max_length {
278            properties.push(("max-length", max_length));
279        }
280        if let Some(ref max_width_chars) = self.max_width_chars {
281            properties.push(("max-width-chars", max_width_chars));
282        }
283        if let Some(ref overwrite_mode) = self.overwrite_mode {
284            properties.push(("overwrite-mode", overwrite_mode));
285        }
286        if let Some(ref placeholder_text) = self.placeholder_text {
287            properties.push(("placeholder-text", placeholder_text));
288        }
289        if let Some(ref populate_all) = self.populate_all {
290            properties.push(("populate-all", populate_all));
291        }
292        if let Some(ref primary_icon_activatable) = self.primary_icon_activatable {
293            properties.push(("primary-icon-activatable", primary_icon_activatable));
294        }
295        if let Some(ref primary_icon_gicon) = self.primary_icon_gicon {
296            properties.push(("primary-icon-gicon", primary_icon_gicon));
297        }
298        if let Some(ref primary_icon_name) = self.primary_icon_name {
299            properties.push(("primary-icon-name", primary_icon_name));
300        }
301        if let Some(ref primary_icon_pixbuf) = self.primary_icon_pixbuf {
302            properties.push(("primary-icon-pixbuf", primary_icon_pixbuf));
303        }
304        if let Some(ref primary_icon_sensitive) = self.primary_icon_sensitive {
305            properties.push(("primary-icon-sensitive", primary_icon_sensitive));
306        }
307        if let Some(ref primary_icon_tooltip_markup) = self.primary_icon_tooltip_markup {
308            properties.push(("primary-icon-tooltip-markup", primary_icon_tooltip_markup));
309        }
310        if let Some(ref primary_icon_tooltip_text) = self.primary_icon_tooltip_text {
311            properties.push(("primary-icon-tooltip-text", primary_icon_tooltip_text));
312        }
313        if let Some(ref progress_fraction) = self.progress_fraction {
314            properties.push(("progress-fraction", progress_fraction));
315        }
316        if let Some(ref progress_pulse_step) = self.progress_pulse_step {
317            properties.push(("progress-pulse-step", progress_pulse_step));
318        }
319        if let Some(ref secondary_icon_activatable) = self.secondary_icon_activatable {
320            properties.push(("secondary-icon-activatable", secondary_icon_activatable));
321        }
322        if let Some(ref secondary_icon_gicon) = self.secondary_icon_gicon {
323            properties.push(("secondary-icon-gicon", secondary_icon_gicon));
324        }
325        if let Some(ref secondary_icon_name) = self.secondary_icon_name {
326            properties.push(("secondary-icon-name", secondary_icon_name));
327        }
328        if let Some(ref secondary_icon_pixbuf) = self.secondary_icon_pixbuf {
329            properties.push(("secondary-icon-pixbuf", secondary_icon_pixbuf));
330        }
331        if let Some(ref secondary_icon_sensitive) = self.secondary_icon_sensitive {
332            properties.push(("secondary-icon-sensitive", secondary_icon_sensitive));
333        }
334        if let Some(ref secondary_icon_tooltip_markup) = self.secondary_icon_tooltip_markup {
335            properties.push((
336                "secondary-icon-tooltip-markup",
337                secondary_icon_tooltip_markup,
338            ));
339        }
340        if let Some(ref secondary_icon_tooltip_text) = self.secondary_icon_tooltip_text {
341            properties.push(("secondary-icon-tooltip-text", secondary_icon_tooltip_text));
342        }
343        if let Some(ref shadow_type) = self.shadow_type {
344            properties.push(("shadow-type", shadow_type));
345        }
346        if let Some(ref show_emoji_icon) = self.show_emoji_icon {
347            properties.push(("show-emoji-icon", show_emoji_icon));
348        }
349        if let Some(ref text) = self.text {
350            properties.push(("text", text));
351        }
352        if let Some(ref truncate_multiline) = self.truncate_multiline {
353            properties.push(("truncate-multiline", truncate_multiline));
354        }
355        if let Some(ref visibility) = self.visibility {
356            properties.push(("visibility", visibility));
357        }
358        if let Some(ref width_chars) = self.width_chars {
359            properties.push(("width-chars", width_chars));
360        }
361        if let Some(ref xalign) = self.xalign {
362            properties.push(("xalign", xalign));
363        }
364        if let Some(ref app_paintable) = self.app_paintable {
365            properties.push(("app-paintable", app_paintable));
366        }
367        if let Some(ref can_default) = self.can_default {
368            properties.push(("can-default", can_default));
369        }
370        if let Some(ref can_focus) = self.can_focus {
371            properties.push(("can-focus", can_focus));
372        }
373        if let Some(ref events) = self.events {
374            properties.push(("events", events));
375        }
376        if let Some(ref expand) = self.expand {
377            properties.push(("expand", expand));
378        }
379        #[cfg(any(feature = "v3_20", feature = "dox"))]
380        {
381            if let Some(ref focus_on_click) = self.focus_on_click {
382                properties.push(("focus-on-click", focus_on_click));
383            }
384        }
385        if let Some(ref halign) = self.halign {
386            properties.push(("halign", halign));
387        }
388        if let Some(ref has_default) = self.has_default {
389            properties.push(("has-default", has_default));
390        }
391        if let Some(ref has_focus) = self.has_focus {
392            properties.push(("has-focus", has_focus));
393        }
394        if let Some(ref has_tooltip) = self.has_tooltip {
395            properties.push(("has-tooltip", has_tooltip));
396        }
397        if let Some(ref height_request) = self.height_request {
398            properties.push(("height-request", height_request));
399        }
400        if let Some(ref hexpand) = self.hexpand {
401            properties.push(("hexpand", hexpand));
402        }
403        if let Some(ref hexpand_set) = self.hexpand_set {
404            properties.push(("hexpand-set", hexpand_set));
405        }
406        if let Some(ref is_focus) = self.is_focus {
407            properties.push(("is-focus", is_focus));
408        }
409        if let Some(ref margin) = self.margin {
410            properties.push(("margin", margin));
411        }
412        if let Some(ref margin_bottom) = self.margin_bottom {
413            properties.push(("margin-bottom", margin_bottom));
414        }
415        if let Some(ref margin_end) = self.margin_end {
416            properties.push(("margin-end", margin_end));
417        }
418        if let Some(ref margin_start) = self.margin_start {
419            properties.push(("margin-start", margin_start));
420        }
421        if let Some(ref margin_top) = self.margin_top {
422            properties.push(("margin-top", margin_top));
423        }
424        if let Some(ref name) = self.name {
425            properties.push(("name", name));
426        }
427        if let Some(ref no_show_all) = self.no_show_all {
428            properties.push(("no-show-all", no_show_all));
429        }
430        if let Some(ref opacity) = self.opacity {
431            properties.push(("opacity", opacity));
432        }
433        if let Some(ref parent) = self.parent {
434            properties.push(("parent", parent));
435        }
436        if let Some(ref receives_default) = self.receives_default {
437            properties.push(("receives-default", receives_default));
438        }
439        if let Some(ref sensitive) = self.sensitive {
440            properties.push(("sensitive", sensitive));
441        }
442        if let Some(ref tooltip_markup) = self.tooltip_markup {
443            properties.push(("tooltip-markup", tooltip_markup));
444        }
445        if let Some(ref tooltip_text) = self.tooltip_text {
446            properties.push(("tooltip-text", tooltip_text));
447        }
448        if let Some(ref valign) = self.valign {
449            properties.push(("valign", valign));
450        }
451        if let Some(ref vexpand) = self.vexpand {
452            properties.push(("vexpand", vexpand));
453        }
454        if let Some(ref vexpand_set) = self.vexpand_set {
455            properties.push(("vexpand-set", vexpand_set));
456        }
457        if let Some(ref visible) = self.visible {
458            properties.push(("visible", visible));
459        }
460        if let Some(ref width_request) = self.width_request {
461            properties.push(("width-request", width_request));
462        }
463        glib::Object::new(Entry::static_type(), &properties)
464            .expect("object new")
465            .downcast()
466            .expect("downcast")
467    }
468
469    pub fn activates_default(mut self, activates_default: bool) -> Self {
470        self.activates_default = Some(activates_default);
471        self
472    }
473
474    pub fn attributes(mut self, attributes: &pango::AttrList) -> Self {
475        self.attributes = Some(attributes.clone());
476        self
477    }
478
479    pub fn buffer(mut self, buffer: &EntryBuffer) -> Self {
480        self.buffer = Some(buffer.clone());
481        self
482    }
483
484    pub fn caps_lock_warning(mut self, caps_lock_warning: bool) -> Self {
485        self.caps_lock_warning = Some(caps_lock_warning);
486        self
487    }
488
489    pub fn completion(mut self, completion: &EntryCompletion) -> Self {
490        self.completion = Some(completion.clone());
491        self
492    }
493
494    pub fn editable(mut self, editable: bool) -> Self {
495        self.editable = Some(editable);
496        self
497    }
498
499    pub fn enable_emoji_completion(mut self, enable_emoji_completion: bool) -> Self {
500        self.enable_emoji_completion = Some(enable_emoji_completion);
501        self
502    }
503
504    pub fn has_frame(mut self, has_frame: bool) -> Self {
505        self.has_frame = Some(has_frame);
506        self
507    }
508
509    pub fn im_module(mut self, im_module: &str) -> Self {
510        self.im_module = Some(im_module.to_string());
511        self
512    }
513
514    pub fn input_hints(mut self, input_hints: InputHints) -> Self {
515        self.input_hints = Some(input_hints);
516        self
517    }
518
519    pub fn input_purpose(mut self, input_purpose: InputPurpose) -> Self {
520        self.input_purpose = Some(input_purpose);
521        self
522    }
523
524    pub fn invisible_char(mut self, invisible_char: u32) -> Self {
525        self.invisible_char = Some(invisible_char);
526        self
527    }
528
529    pub fn invisible_char_set(mut self, invisible_char_set: bool) -> Self {
530        self.invisible_char_set = Some(invisible_char_set);
531        self
532    }
533
534    pub fn max_length(mut self, max_length: i32) -> Self {
535        self.max_length = Some(max_length);
536        self
537    }
538
539    pub fn max_width_chars(mut self, max_width_chars: i32) -> Self {
540        self.max_width_chars = Some(max_width_chars);
541        self
542    }
543
544    pub fn overwrite_mode(mut self, overwrite_mode: bool) -> Self {
545        self.overwrite_mode = Some(overwrite_mode);
546        self
547    }
548
549    pub fn placeholder_text(mut self, placeholder_text: &str) -> Self {
550        self.placeholder_text = Some(placeholder_text.to_string());
551        self
552    }
553
554    pub fn populate_all(mut self, populate_all: bool) -> Self {
555        self.populate_all = Some(populate_all);
556        self
557    }
558
559    pub fn primary_icon_activatable(mut self, primary_icon_activatable: bool) -> Self {
560        self.primary_icon_activatable = Some(primary_icon_activatable);
561        self
562    }
563
564    pub fn primary_icon_gicon(mut self, primary_icon_gicon: &gio::Icon) -> Self {
565        self.primary_icon_gicon = Some(primary_icon_gicon.clone());
566        self
567    }
568
569    pub fn primary_icon_name(mut self, primary_icon_name: &str) -> Self {
570        self.primary_icon_name = Some(primary_icon_name.to_string());
571        self
572    }
573
574    pub fn primary_icon_pixbuf(mut self, primary_icon_pixbuf: &gdk_pixbuf::Pixbuf) -> Self {
575        self.primary_icon_pixbuf = Some(primary_icon_pixbuf.clone());
576        self
577    }
578
579    pub fn primary_icon_sensitive(mut self, primary_icon_sensitive: bool) -> Self {
580        self.primary_icon_sensitive = Some(primary_icon_sensitive);
581        self
582    }
583
584    pub fn primary_icon_tooltip_markup(mut self, primary_icon_tooltip_markup: &str) -> Self {
585        self.primary_icon_tooltip_markup = Some(primary_icon_tooltip_markup.to_string());
586        self
587    }
588
589    pub fn primary_icon_tooltip_text(mut self, primary_icon_tooltip_text: &str) -> Self {
590        self.primary_icon_tooltip_text = Some(primary_icon_tooltip_text.to_string());
591        self
592    }
593
594    pub fn progress_fraction(mut self, progress_fraction: f64) -> Self {
595        self.progress_fraction = Some(progress_fraction);
596        self
597    }
598
599    pub fn progress_pulse_step(mut self, progress_pulse_step: f64) -> Self {
600        self.progress_pulse_step = Some(progress_pulse_step);
601        self
602    }
603
604    pub fn secondary_icon_activatable(mut self, secondary_icon_activatable: bool) -> Self {
605        self.secondary_icon_activatable = Some(secondary_icon_activatable);
606        self
607    }
608
609    pub fn secondary_icon_gicon(mut self, secondary_icon_gicon: &gio::Icon) -> Self {
610        self.secondary_icon_gicon = Some(secondary_icon_gicon.clone());
611        self
612    }
613
614    pub fn secondary_icon_name(mut self, secondary_icon_name: &str) -> Self {
615        self.secondary_icon_name = Some(secondary_icon_name.to_string());
616        self
617    }
618
619    pub fn secondary_icon_pixbuf(mut self, secondary_icon_pixbuf: &gdk_pixbuf::Pixbuf) -> Self {
620        self.secondary_icon_pixbuf = Some(secondary_icon_pixbuf.clone());
621        self
622    }
623
624    pub fn secondary_icon_sensitive(mut self, secondary_icon_sensitive: bool) -> Self {
625        self.secondary_icon_sensitive = Some(secondary_icon_sensitive);
626        self
627    }
628
629    pub fn secondary_icon_tooltip_markup(mut self, secondary_icon_tooltip_markup: &str) -> Self {
630        self.secondary_icon_tooltip_markup = Some(secondary_icon_tooltip_markup.to_string());
631        self
632    }
633
634    pub fn secondary_icon_tooltip_text(mut self, secondary_icon_tooltip_text: &str) -> Self {
635        self.secondary_icon_tooltip_text = Some(secondary_icon_tooltip_text.to_string());
636        self
637    }
638
639    pub fn shadow_type(mut self, shadow_type: ShadowType) -> Self {
640        self.shadow_type = Some(shadow_type);
641        self
642    }
643
644    pub fn show_emoji_icon(mut self, show_emoji_icon: bool) -> Self {
645        self.show_emoji_icon = Some(show_emoji_icon);
646        self
647    }
648
649    pub fn text(mut self, text: &str) -> Self {
650        self.text = Some(text.to_string());
651        self
652    }
653
654    pub fn truncate_multiline(mut self, truncate_multiline: bool) -> Self {
655        self.truncate_multiline = Some(truncate_multiline);
656        self
657    }
658
659    pub fn visibility(mut self, visibility: bool) -> Self {
660        self.visibility = Some(visibility);
661        self
662    }
663
664    pub fn width_chars(mut self, width_chars: i32) -> Self {
665        self.width_chars = Some(width_chars);
666        self
667    }
668
669    pub fn xalign(mut self, xalign: f32) -> Self {
670        self.xalign = Some(xalign);
671        self
672    }
673
674    pub fn app_paintable(mut self, app_paintable: bool) -> Self {
675        self.app_paintable = Some(app_paintable);
676        self
677    }
678
679    pub fn can_default(mut self, can_default: bool) -> Self {
680        self.can_default = Some(can_default);
681        self
682    }
683
684    pub fn can_focus(mut self, can_focus: bool) -> Self {
685        self.can_focus = Some(can_focus);
686        self
687    }
688
689    pub fn events(mut self, events: gdk::EventMask) -> Self {
690        self.events = Some(events);
691        self
692    }
693
694    pub fn expand(mut self, expand: bool) -> Self {
695        self.expand = Some(expand);
696        self
697    }
698
699    #[cfg(any(feature = "v3_20", feature = "dox"))]
700    pub fn focus_on_click(mut self, focus_on_click: bool) -> Self {
701        self.focus_on_click = Some(focus_on_click);
702        self
703    }
704
705    pub fn halign(mut self, halign: Align) -> Self {
706        self.halign = Some(halign);
707        self
708    }
709
710    pub fn has_default(mut self, has_default: bool) -> Self {
711        self.has_default = Some(has_default);
712        self
713    }
714
715    pub fn has_focus(mut self, has_focus: bool) -> Self {
716        self.has_focus = Some(has_focus);
717        self
718    }
719
720    pub fn has_tooltip(mut self, has_tooltip: bool) -> Self {
721        self.has_tooltip = Some(has_tooltip);
722        self
723    }
724
725    pub fn height_request(mut self, height_request: i32) -> Self {
726        self.height_request = Some(height_request);
727        self
728    }
729
730    pub fn hexpand(mut self, hexpand: bool) -> Self {
731        self.hexpand = Some(hexpand);
732        self
733    }
734
735    pub fn hexpand_set(mut self, hexpand_set: bool) -> Self {
736        self.hexpand_set = Some(hexpand_set);
737        self
738    }
739
740    pub fn is_focus(mut self, is_focus: bool) -> Self {
741        self.is_focus = Some(is_focus);
742        self
743    }
744
745    pub fn margin(mut self, margin: i32) -> Self {
746        self.margin = Some(margin);
747        self
748    }
749
750    pub fn margin_bottom(mut self, margin_bottom: i32) -> Self {
751        self.margin_bottom = Some(margin_bottom);
752        self
753    }
754
755    pub fn margin_end(mut self, margin_end: i32) -> Self {
756        self.margin_end = Some(margin_end);
757        self
758    }
759
760    pub fn margin_start(mut self, margin_start: i32) -> Self {
761        self.margin_start = Some(margin_start);
762        self
763    }
764
765    pub fn margin_top(mut self, margin_top: i32) -> Self {
766        self.margin_top = Some(margin_top);
767        self
768    }
769
770    pub fn name(mut self, name: &str) -> Self {
771        self.name = Some(name.to_string());
772        self
773    }
774
775    pub fn no_show_all(mut self, no_show_all: bool) -> Self {
776        self.no_show_all = Some(no_show_all);
777        self
778    }
779
780    pub fn opacity(mut self, opacity: f64) -> Self {
781        self.opacity = Some(opacity);
782        self
783    }
784
785    pub fn parent(mut self, parent: &Container) -> Self {
786        self.parent = Some(parent.clone());
787        self
788    }
789
790    pub fn receives_default(mut self, receives_default: bool) -> Self {
791        self.receives_default = Some(receives_default);
792        self
793    }
794
795    pub fn sensitive(mut self, sensitive: bool) -> Self {
796        self.sensitive = Some(sensitive);
797        self
798    }
799
800    pub fn tooltip_markup(mut self, tooltip_markup: &str) -> Self {
801        self.tooltip_markup = Some(tooltip_markup.to_string());
802        self
803    }
804
805    pub fn tooltip_text(mut self, tooltip_text: &str) -> Self {
806        self.tooltip_text = Some(tooltip_text.to_string());
807        self
808    }
809
810    pub fn valign(mut self, valign: Align) -> Self {
811        self.valign = Some(valign);
812        self
813    }
814
815    pub fn vexpand(mut self, vexpand: bool) -> Self {
816        self.vexpand = Some(vexpand);
817        self
818    }
819
820    pub fn vexpand_set(mut self, vexpand_set: bool) -> Self {
821        self.vexpand_set = Some(vexpand_set);
822        self
823    }
824
825    pub fn visible(mut self, visible: bool) -> Self {
826        self.visible = Some(visible);
827        self
828    }
829
830    pub fn width_request(mut self, width_request: i32) -> Self {
831        self.width_request = Some(width_request);
832        self
833    }
834}
835
836pub const NONE_ENTRY: Option<&Entry> = None;
837
838pub trait EntryExt: 'static {
839    fn get_activates_default(&self) -> bool;
840
841    fn get_alignment(&self) -> f32;
842
843    fn get_attributes(&self) -> Option<pango::AttrList>;
844
845    fn get_buffer(&self) -> EntryBuffer;
846
847    fn get_completion(&self) -> Option<EntryCompletion>;
848
849    fn get_current_icon_drag_source(&self) -> i32;
850
851    fn get_cursor_hadjustment(&self) -> Option<Adjustment>;
852
853    fn get_has_frame(&self) -> bool;
854
855    fn get_icon_activatable(&self, icon_pos: EntryIconPosition) -> bool;
856
857    fn get_icon_area(&self, icon_pos: EntryIconPosition) -> gdk::Rectangle;
858
859    fn get_icon_at_pos(&self, x: i32, y: i32) -> i32;
860
861    fn get_icon_gicon(&self, icon_pos: EntryIconPosition) -> Option<gio::Icon>;
862
863    fn get_icon_name(&self, icon_pos: EntryIconPosition) -> Option<GString>;
864
865    fn get_icon_pixbuf(&self, icon_pos: EntryIconPosition) -> Option<gdk_pixbuf::Pixbuf>;
866
867    fn get_icon_sensitive(&self, icon_pos: EntryIconPosition) -> bool;
868
869    fn get_icon_storage_type(&self, icon_pos: EntryIconPosition) -> ImageType;
870
871    fn get_icon_tooltip_markup(&self, icon_pos: EntryIconPosition) -> Option<GString>;
872
873    fn get_icon_tooltip_text(&self, icon_pos: EntryIconPosition) -> Option<GString>;
874
875    fn get_input_hints(&self) -> InputHints;
876
877    fn get_input_purpose(&self) -> InputPurpose;
878
879    fn get_invisible_char(&self) -> Option<char>;
880
881    fn get_layout(&self) -> Option<pango::Layout>;
882
883    fn get_layout_offsets(&self) -> (i32, i32);
884
885    fn get_max_length(&self) -> i32;
886
887    fn get_max_width_chars(&self) -> i32;
888
889    fn get_overwrite_mode(&self) -> bool;
890
891    fn get_placeholder_text(&self) -> Option<GString>;
892
893    fn get_progress_fraction(&self) -> f64;
894
895    fn get_progress_pulse_step(&self) -> f64;
896
897    fn get_tabs(&self) -> Option<pango::TabArray>;
898
899    fn get_text(&self) -> Option<GString>;
900
901    fn get_text_area(&self) -> gdk::Rectangle;
902
903    fn get_text_length(&self) -> u16;
904
905    fn get_visibility(&self) -> bool;
906
907    fn get_width_chars(&self) -> i32;
908
909    #[cfg(any(feature = "v3_16", feature = "dox"))]
910    fn grab_focus_without_selecting(&self);
911
912    fn im_context_filter_keypress(&self, event: &gdk::EventKey) -> bool;
913
914    fn layout_index_to_text_index(&self, layout_index: i32) -> i32;
915
916    fn progress_pulse(&self);
917
918    fn reset_im_context(&self);
919
920    fn set_activates_default(&self, setting: bool);
921
922    fn set_alignment(&self, xalign: f32);
923
924    fn set_attributes(&self, attrs: &pango::AttrList);
925
926    fn set_buffer<P: IsA<EntryBuffer>>(&self, buffer: &P);
927
928    fn set_completion<P: IsA<EntryCompletion>>(&self, completion: Option<&P>);
929
930    fn set_cursor_hadjustment<P: IsA<Adjustment>>(&self, adjustment: Option<&P>);
931
932    fn set_has_frame(&self, setting: bool);
933
934    fn set_icon_activatable(&self, icon_pos: EntryIconPosition, activatable: bool);
935
936    fn set_icon_drag_source(
937        &self,
938        icon_pos: EntryIconPosition,
939        target_list: &TargetList,
940        actions: gdk::DragAction,
941    );
942
943    fn set_icon_from_gicon<P: IsA<gio::Icon>>(&self, icon_pos: EntryIconPosition, icon: Option<&P>);
944
945    fn set_icon_from_icon_name(&self, icon_pos: EntryIconPosition, icon_name: Option<&str>);
946
947    fn set_icon_from_pixbuf(
948        &self,
949        icon_pos: EntryIconPosition,
950        pixbuf: Option<&gdk_pixbuf::Pixbuf>,
951    );
952
953    fn set_icon_sensitive(&self, icon_pos: EntryIconPosition, sensitive: bool);
954
955    fn set_icon_tooltip_markup(&self, icon_pos: EntryIconPosition, tooltip: Option<&str>);
956
957    fn set_icon_tooltip_text(&self, icon_pos: EntryIconPosition, tooltip: Option<&str>);
958
959    fn set_input_hints(&self, hints: InputHints);
960
961    fn set_input_purpose(&self, purpose: InputPurpose);
962
963    fn set_invisible_char(&self, ch: Option<char>);
964
965    fn set_max_length(&self, max: i32);
966
967    fn set_max_width_chars(&self, n_chars: i32);
968
969    fn set_overwrite_mode(&self, overwrite: bool);
970
971    fn set_placeholder_text(&self, text: Option<&str>);
972
973    fn set_progress_fraction(&self, fraction: f64);
974
975    fn set_progress_pulse_step(&self, fraction: f64);
976
977    fn set_tabs(&self, tabs: &pango::TabArray);
978
979    fn set_text(&self, text: &str);
980
981    fn set_visibility(&self, visible: bool);
982
983    fn set_width_chars(&self, n_chars: i32);
984
985    fn text_index_to_layout_index(&self, text_index: i32) -> i32;
986
987    fn unset_invisible_char(&self);
988
989    fn get_property_caps_lock_warning(&self) -> bool;
990
991    fn set_property_caps_lock_warning(&self, caps_lock_warning: bool);
992
993    fn get_property_cursor_position(&self) -> i32;
994
995    fn get_property_enable_emoji_completion(&self) -> bool;
996
997    fn set_property_enable_emoji_completion(&self, enable_emoji_completion: bool);
998
999    fn get_property_im_module(&self) -> Option<GString>;
1000
1001    fn set_property_im_module(&self, im_module: Option<&str>);
1002
1003    fn get_property_invisible_char_set(&self) -> bool;
1004
1005    fn set_property_invisible_char_set(&self, invisible_char_set: bool);
1006
1007    fn get_property_populate_all(&self) -> bool;
1008
1009    fn set_property_populate_all(&self, populate_all: bool);
1010
1011    fn get_property_primary_icon_activatable(&self) -> bool;
1012
1013    fn set_property_primary_icon_activatable(&self, primary_icon_activatable: bool);
1014
1015    fn get_property_primary_icon_gicon(&self) -> Option<gio::Icon>;
1016
1017    fn set_property_primary_icon_gicon(&self, primary_icon_gicon: Option<&gio::Icon>);
1018
1019    fn get_property_primary_icon_name(&self) -> Option<GString>;
1020
1021    fn set_property_primary_icon_name(&self, primary_icon_name: Option<&str>);
1022
1023    fn get_property_primary_icon_pixbuf(&self) -> Option<gdk_pixbuf::Pixbuf>;
1024
1025    fn set_property_primary_icon_pixbuf(&self, primary_icon_pixbuf: Option<&gdk_pixbuf::Pixbuf>);
1026
1027    fn get_property_primary_icon_sensitive(&self) -> bool;
1028
1029    fn set_property_primary_icon_sensitive(&self, primary_icon_sensitive: bool);
1030
1031    fn get_property_primary_icon_storage_type(&self) -> ImageType;
1032
1033    fn get_property_primary_icon_tooltip_markup(&self) -> Option<GString>;
1034
1035    fn set_property_primary_icon_tooltip_markup(&self, primary_icon_tooltip_markup: Option<&str>);
1036
1037    fn get_property_primary_icon_tooltip_text(&self) -> Option<GString>;
1038
1039    fn set_property_primary_icon_tooltip_text(&self, primary_icon_tooltip_text: Option<&str>);
1040
1041    fn get_property_scroll_offset(&self) -> i32;
1042
1043    fn get_property_secondary_icon_activatable(&self) -> bool;
1044
1045    fn set_property_secondary_icon_activatable(&self, secondary_icon_activatable: bool);
1046
1047    fn get_property_secondary_icon_gicon(&self) -> Option<gio::Icon>;
1048
1049    fn set_property_secondary_icon_gicon(&self, secondary_icon_gicon: Option<&gio::Icon>);
1050
1051    fn get_property_secondary_icon_name(&self) -> Option<GString>;
1052
1053    fn set_property_secondary_icon_name(&self, secondary_icon_name: Option<&str>);
1054
1055    fn get_property_secondary_icon_pixbuf(&self) -> Option<gdk_pixbuf::Pixbuf>;
1056
1057    fn set_property_secondary_icon_pixbuf(
1058        &self,
1059        secondary_icon_pixbuf: Option<&gdk_pixbuf::Pixbuf>,
1060    );
1061
1062    fn get_property_secondary_icon_sensitive(&self) -> bool;
1063
1064    fn set_property_secondary_icon_sensitive(&self, secondary_icon_sensitive: bool);
1065
1066    fn get_property_secondary_icon_storage_type(&self) -> ImageType;
1067
1068    fn get_property_secondary_icon_tooltip_markup(&self) -> Option<GString>;
1069
1070    fn set_property_secondary_icon_tooltip_markup(
1071        &self,
1072        secondary_icon_tooltip_markup: Option<&str>,
1073    );
1074
1075    fn get_property_secondary_icon_tooltip_text(&self) -> Option<GString>;
1076
1077    fn set_property_secondary_icon_tooltip_text(&self, secondary_icon_tooltip_text: Option<&str>);
1078
1079    fn get_property_selection_bound(&self) -> i32;
1080
1081    #[cfg_attr(feature = "v3_20", deprecated)]
1082    fn get_property_shadow_type(&self) -> ShadowType;
1083
1084    #[cfg_attr(feature = "v3_20", deprecated)]
1085    fn set_property_shadow_type(&self, shadow_type: ShadowType);
1086
1087    fn get_property_show_emoji_icon(&self) -> bool;
1088
1089    fn set_property_show_emoji_icon(&self, show_emoji_icon: bool);
1090
1091    fn get_property_truncate_multiline(&self) -> bool;
1092
1093    fn set_property_truncate_multiline(&self, truncate_multiline: bool);
1094
1095    fn get_property_xalign(&self) -> f32;
1096
1097    fn set_property_xalign(&self, xalign: f32);
1098
1099    fn connect_activate<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1100
1101    fn emit_activate(&self);
1102
1103    fn connect_backspace<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1104
1105    fn emit_backspace(&self);
1106
1107    fn connect_copy_clipboard<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1108
1109    fn emit_copy_clipboard(&self);
1110
1111    fn connect_cut_clipboard<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1112
1113    fn emit_cut_clipboard(&self);
1114
1115    fn connect_delete_from_cursor<F: Fn(&Self, DeleteType, i32) + 'static>(
1116        &self,
1117        f: F,
1118    ) -> SignalHandlerId;
1119
1120    fn emit_delete_from_cursor(&self, type_: DeleteType, count: i32);
1121
1122    fn connect_icon_press<F: Fn(&Self, EntryIconPosition, &gdk::EventButton) + 'static>(
1123        &self,
1124        f: F,
1125    ) -> SignalHandlerId;
1126
1127    fn connect_icon_release<F: Fn(&Self, EntryIconPosition, &gdk::EventButton) + 'static>(
1128        &self,
1129        f: F,
1130    ) -> SignalHandlerId;
1131
1132    fn connect_insert_at_cursor<F: Fn(&Self, &str) + 'static>(&self, f: F) -> SignalHandlerId;
1133
1134    fn emit_insert_at_cursor(&self, string: &str);
1135
1136    #[cfg(any(feature = "v3_22_27", feature = "dox"))]
1137    fn connect_insert_emoji<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1138
1139    #[cfg(any(feature = "v3_22_27", feature = "dox"))]
1140    fn emit_insert_emoji(&self);
1141
1142    fn connect_move_cursor<F: Fn(&Self, MovementStep, i32, bool) + 'static>(
1143        &self,
1144        f: F,
1145    ) -> SignalHandlerId;
1146
1147    fn emit_move_cursor(&self, step: MovementStep, count: i32, extend_selection: bool);
1148
1149    fn connect_paste_clipboard<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1150
1151    fn emit_paste_clipboard(&self);
1152
1153    fn connect_populate_popup<F: Fn(&Self, &Widget) + 'static>(&self, f: F) -> SignalHandlerId;
1154
1155    fn connect_preedit_changed<F: Fn(&Self, &str) + 'static>(&self, f: F) -> SignalHandlerId;
1156
1157    fn emit_preedit_changed(&self, preedit: &str);
1158
1159    fn connect_toggle_overwrite<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1160
1161    fn emit_toggle_overwrite(&self);
1162
1163    fn connect_property_activates_default_notify<F: Fn(&Self) + 'static>(
1164        &self,
1165        f: F,
1166    ) -> SignalHandlerId;
1167
1168    fn connect_property_attributes_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1169
1170    fn connect_property_buffer_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1171
1172    fn connect_property_caps_lock_warning_notify<F: Fn(&Self) + 'static>(
1173        &self,
1174        f: F,
1175    ) -> SignalHandlerId;
1176
1177    fn connect_property_completion_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1178
1179    fn connect_property_cursor_position_notify<F: Fn(&Self) + 'static>(
1180        &self,
1181        f: F,
1182    ) -> SignalHandlerId;
1183
1184    fn connect_property_editable_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1185
1186    fn connect_property_enable_emoji_completion_notify<F: Fn(&Self) + 'static>(
1187        &self,
1188        f: F,
1189    ) -> SignalHandlerId;
1190
1191    fn connect_property_has_frame_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1192
1193    fn connect_property_im_module_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1194
1195    fn connect_property_input_hints_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1196
1197    fn connect_property_input_purpose_notify<F: Fn(&Self) + 'static>(
1198        &self,
1199        f: F,
1200    ) -> SignalHandlerId;
1201
1202    fn connect_property_invisible_char_notify<F: Fn(&Self) + 'static>(
1203        &self,
1204        f: F,
1205    ) -> SignalHandlerId;
1206
1207    fn connect_property_invisible_char_set_notify<F: Fn(&Self) + 'static>(
1208        &self,
1209        f: F,
1210    ) -> SignalHandlerId;
1211
1212    fn connect_property_max_length_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1213
1214    fn connect_property_max_width_chars_notify<F: Fn(&Self) + 'static>(
1215        &self,
1216        f: F,
1217    ) -> SignalHandlerId;
1218
1219    fn connect_property_overwrite_mode_notify<F: Fn(&Self) + 'static>(
1220        &self,
1221        f: F,
1222    ) -> SignalHandlerId;
1223
1224    fn connect_property_placeholder_text_notify<F: Fn(&Self) + 'static>(
1225        &self,
1226        f: F,
1227    ) -> SignalHandlerId;
1228
1229    fn connect_property_populate_all_notify<F: Fn(&Self) + 'static>(&self, f: F)
1230        -> SignalHandlerId;
1231
1232    fn connect_property_primary_icon_activatable_notify<F: Fn(&Self) + 'static>(
1233        &self,
1234        f: F,
1235    ) -> SignalHandlerId;
1236
1237    fn connect_property_primary_icon_gicon_notify<F: Fn(&Self) + 'static>(
1238        &self,
1239        f: F,
1240    ) -> SignalHandlerId;
1241
1242    fn connect_property_primary_icon_name_notify<F: Fn(&Self) + 'static>(
1243        &self,
1244        f: F,
1245    ) -> SignalHandlerId;
1246
1247    fn connect_property_primary_icon_pixbuf_notify<F: Fn(&Self) + 'static>(
1248        &self,
1249        f: F,
1250    ) -> SignalHandlerId;
1251
1252    fn connect_property_primary_icon_sensitive_notify<F: Fn(&Self) + 'static>(
1253        &self,
1254        f: F,
1255    ) -> SignalHandlerId;
1256
1257    fn connect_property_primary_icon_storage_type_notify<F: Fn(&Self) + 'static>(
1258        &self,
1259        f: F,
1260    ) -> SignalHandlerId;
1261
1262    fn connect_property_primary_icon_tooltip_markup_notify<F: Fn(&Self) + 'static>(
1263        &self,
1264        f: F,
1265    ) -> SignalHandlerId;
1266
1267    fn connect_property_primary_icon_tooltip_text_notify<F: Fn(&Self) + 'static>(
1268        &self,
1269        f: F,
1270    ) -> SignalHandlerId;
1271
1272    fn connect_property_progress_fraction_notify<F: Fn(&Self) + 'static>(
1273        &self,
1274        f: F,
1275    ) -> SignalHandlerId;
1276
1277    fn connect_property_progress_pulse_step_notify<F: Fn(&Self) + 'static>(
1278        &self,
1279        f: F,
1280    ) -> SignalHandlerId;
1281
1282    fn connect_property_scroll_offset_notify<F: Fn(&Self) + 'static>(
1283        &self,
1284        f: F,
1285    ) -> SignalHandlerId;
1286
1287    fn connect_property_secondary_icon_activatable_notify<F: Fn(&Self) + 'static>(
1288        &self,
1289        f: F,
1290    ) -> SignalHandlerId;
1291
1292    fn connect_property_secondary_icon_gicon_notify<F: Fn(&Self) + 'static>(
1293        &self,
1294        f: F,
1295    ) -> SignalHandlerId;
1296
1297    fn connect_property_secondary_icon_name_notify<F: Fn(&Self) + 'static>(
1298        &self,
1299        f: F,
1300    ) -> SignalHandlerId;
1301
1302    fn connect_property_secondary_icon_pixbuf_notify<F: Fn(&Self) + 'static>(
1303        &self,
1304        f: F,
1305    ) -> SignalHandlerId;
1306
1307    fn connect_property_secondary_icon_sensitive_notify<F: Fn(&Self) + 'static>(
1308        &self,
1309        f: F,
1310    ) -> SignalHandlerId;
1311
1312    fn connect_property_secondary_icon_storage_type_notify<F: Fn(&Self) + 'static>(
1313        &self,
1314        f: F,
1315    ) -> SignalHandlerId;
1316
1317    fn connect_property_secondary_icon_tooltip_markup_notify<F: Fn(&Self) + 'static>(
1318        &self,
1319        f: F,
1320    ) -> SignalHandlerId;
1321
1322    fn connect_property_secondary_icon_tooltip_text_notify<F: Fn(&Self) + 'static>(
1323        &self,
1324        f: F,
1325    ) -> SignalHandlerId;
1326
1327    fn connect_property_selection_bound_notify<F: Fn(&Self) + 'static>(
1328        &self,
1329        f: F,
1330    ) -> SignalHandlerId;
1331
1332    #[cfg_attr(feature = "v3_20", deprecated)]
1333    fn connect_property_shadow_type_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1334
1335    fn connect_property_show_emoji_icon_notify<F: Fn(&Self) + 'static>(
1336        &self,
1337        f: F,
1338    ) -> SignalHandlerId;
1339
1340    fn connect_property_text_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1341
1342    fn connect_property_text_length_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1343
1344    fn connect_property_truncate_multiline_notify<F: Fn(&Self) + 'static>(
1345        &self,
1346        f: F,
1347    ) -> SignalHandlerId;
1348
1349    fn connect_property_visibility_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1350
1351    fn connect_property_width_chars_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1352
1353    fn connect_property_xalign_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1354}
1355
1356impl<O: IsA<Entry>> EntryExt for O {
1357    fn get_activates_default(&self) -> bool {
1358        unsafe {
1359            from_glib(gtk_sys::gtk_entry_get_activates_default(
1360                self.as_ref().to_glib_none().0,
1361            ))
1362        }
1363    }
1364
1365    fn get_alignment(&self) -> f32 {
1366        unsafe { gtk_sys::gtk_entry_get_alignment(self.as_ref().to_glib_none().0) }
1367    }
1368
1369    fn get_attributes(&self) -> Option<pango::AttrList> {
1370        unsafe {
1371            from_glib_none(gtk_sys::gtk_entry_get_attributes(
1372                self.as_ref().to_glib_none().0,
1373            ))
1374        }
1375    }
1376
1377    fn get_buffer(&self) -> EntryBuffer {
1378        unsafe {
1379            from_glib_none(gtk_sys::gtk_entry_get_buffer(
1380                self.as_ref().to_glib_none().0,
1381            ))
1382        }
1383    }
1384
1385    fn get_completion(&self) -> Option<EntryCompletion> {
1386        unsafe {
1387            from_glib_none(gtk_sys::gtk_entry_get_completion(
1388                self.as_ref().to_glib_none().0,
1389            ))
1390        }
1391    }
1392
1393    fn get_current_icon_drag_source(&self) -> i32 {
1394        unsafe { gtk_sys::gtk_entry_get_current_icon_drag_source(self.as_ref().to_glib_none().0) }
1395    }
1396
1397    fn get_cursor_hadjustment(&self) -> Option<Adjustment> {
1398        unsafe {
1399            from_glib_none(gtk_sys::gtk_entry_get_cursor_hadjustment(
1400                self.as_ref().to_glib_none().0,
1401            ))
1402        }
1403    }
1404
1405    fn get_has_frame(&self) -> bool {
1406        unsafe {
1407            from_glib(gtk_sys::gtk_entry_get_has_frame(
1408                self.as_ref().to_glib_none().0,
1409            ))
1410        }
1411    }
1412
1413    fn get_icon_activatable(&self, icon_pos: EntryIconPosition) -> bool {
1414        unsafe {
1415            from_glib(gtk_sys::gtk_entry_get_icon_activatable(
1416                self.as_ref().to_glib_none().0,
1417                icon_pos.to_glib(),
1418            ))
1419        }
1420    }
1421
1422    fn get_icon_area(&self, icon_pos: EntryIconPosition) -> gdk::Rectangle {
1423        unsafe {
1424            let mut icon_area = gdk::Rectangle::uninitialized();
1425            gtk_sys::gtk_entry_get_icon_area(
1426                self.as_ref().to_glib_none().0,
1427                icon_pos.to_glib(),
1428                icon_area.to_glib_none_mut().0,
1429            );
1430            icon_area
1431        }
1432    }
1433
1434    fn get_icon_at_pos(&self, x: i32, y: i32) -> i32 {
1435        unsafe { gtk_sys::gtk_entry_get_icon_at_pos(self.as_ref().to_glib_none().0, x, y) }
1436    }
1437
1438    fn get_icon_gicon(&self, icon_pos: EntryIconPosition) -> Option<gio::Icon> {
1439        unsafe {
1440            from_glib_none(gtk_sys::gtk_entry_get_icon_gicon(
1441                self.as_ref().to_glib_none().0,
1442                icon_pos.to_glib(),
1443            ))
1444        }
1445    }
1446
1447    fn get_icon_name(&self, icon_pos: EntryIconPosition) -> Option<GString> {
1448        unsafe {
1449            from_glib_none(gtk_sys::gtk_entry_get_icon_name(
1450                self.as_ref().to_glib_none().0,
1451                icon_pos.to_glib(),
1452            ))
1453        }
1454    }
1455
1456    fn get_icon_pixbuf(&self, icon_pos: EntryIconPosition) -> Option<gdk_pixbuf::Pixbuf> {
1457        unsafe {
1458            from_glib_none(gtk_sys::gtk_entry_get_icon_pixbuf(
1459                self.as_ref().to_glib_none().0,
1460                icon_pos.to_glib(),
1461            ))
1462        }
1463    }
1464
1465    fn get_icon_sensitive(&self, icon_pos: EntryIconPosition) -> bool {
1466        unsafe {
1467            from_glib(gtk_sys::gtk_entry_get_icon_sensitive(
1468                self.as_ref().to_glib_none().0,
1469                icon_pos.to_glib(),
1470            ))
1471        }
1472    }
1473
1474    fn get_icon_storage_type(&self, icon_pos: EntryIconPosition) -> ImageType {
1475        unsafe {
1476            from_glib(gtk_sys::gtk_entry_get_icon_storage_type(
1477                self.as_ref().to_glib_none().0,
1478                icon_pos.to_glib(),
1479            ))
1480        }
1481    }
1482
1483    fn get_icon_tooltip_markup(&self, icon_pos: EntryIconPosition) -> Option<GString> {
1484        unsafe {
1485            from_glib_full(gtk_sys::gtk_entry_get_icon_tooltip_markup(
1486                self.as_ref().to_glib_none().0,
1487                icon_pos.to_glib(),
1488            ))
1489        }
1490    }
1491
1492    fn get_icon_tooltip_text(&self, icon_pos: EntryIconPosition) -> Option<GString> {
1493        unsafe {
1494            from_glib_full(gtk_sys::gtk_entry_get_icon_tooltip_text(
1495                self.as_ref().to_glib_none().0,
1496                icon_pos.to_glib(),
1497            ))
1498        }
1499    }
1500
1501    fn get_input_hints(&self) -> InputHints {
1502        unsafe {
1503            from_glib(gtk_sys::gtk_entry_get_input_hints(
1504                self.as_ref().to_glib_none().0,
1505            ))
1506        }
1507    }
1508
1509    fn get_input_purpose(&self) -> InputPurpose {
1510        unsafe {
1511            from_glib(gtk_sys::gtk_entry_get_input_purpose(
1512                self.as_ref().to_glib_none().0,
1513            ))
1514        }
1515    }
1516
1517    fn get_invisible_char(&self) -> Option<char> {
1518        unsafe {
1519            from_glib(gtk_sys::gtk_entry_get_invisible_char(
1520                self.as_ref().to_glib_none().0,
1521            ))
1522        }
1523    }
1524
1525    fn get_layout(&self) -> Option<pango::Layout> {
1526        unsafe {
1527            from_glib_none(gtk_sys::gtk_entry_get_layout(
1528                self.as_ref().to_glib_none().0,
1529            ))
1530        }
1531    }
1532
1533    fn get_layout_offsets(&self) -> (i32, i32) {
1534        unsafe {
1535            let mut x = mem::uninitialized();
1536            let mut y = mem::uninitialized();
1537            gtk_sys::gtk_entry_get_layout_offsets(self.as_ref().to_glib_none().0, &mut x, &mut y);
1538            (x, y)
1539        }
1540    }
1541
1542    fn get_max_length(&self) -> i32 {
1543        unsafe { gtk_sys::gtk_entry_get_max_length(self.as_ref().to_glib_none().0) }
1544    }
1545
1546    fn get_max_width_chars(&self) -> i32 {
1547        unsafe { gtk_sys::gtk_entry_get_max_width_chars(self.as_ref().to_glib_none().0) }
1548    }
1549
1550    fn get_overwrite_mode(&self) -> bool {
1551        unsafe {
1552            from_glib(gtk_sys::gtk_entry_get_overwrite_mode(
1553                self.as_ref().to_glib_none().0,
1554            ))
1555        }
1556    }
1557
1558    fn get_placeholder_text(&self) -> Option<GString> {
1559        unsafe {
1560            from_glib_none(gtk_sys::gtk_entry_get_placeholder_text(
1561                self.as_ref().to_glib_none().0,
1562            ))
1563        }
1564    }
1565
1566    fn get_progress_fraction(&self) -> f64 {
1567        unsafe { gtk_sys::gtk_entry_get_progress_fraction(self.as_ref().to_glib_none().0) }
1568    }
1569
1570    fn get_progress_pulse_step(&self) -> f64 {
1571        unsafe { gtk_sys::gtk_entry_get_progress_pulse_step(self.as_ref().to_glib_none().0) }
1572    }
1573
1574    fn get_tabs(&self) -> Option<pango::TabArray> {
1575        unsafe { from_glib_none(gtk_sys::gtk_entry_get_tabs(self.as_ref().to_glib_none().0)) }
1576    }
1577
1578    fn get_text(&self) -> Option<GString> {
1579        unsafe { from_glib_none(gtk_sys::gtk_entry_get_text(self.as_ref().to_glib_none().0)) }
1580    }
1581
1582    fn get_text_area(&self) -> gdk::Rectangle {
1583        unsafe {
1584            let mut text_area = gdk::Rectangle::uninitialized();
1585            gtk_sys::gtk_entry_get_text_area(
1586                self.as_ref().to_glib_none().0,
1587                text_area.to_glib_none_mut().0,
1588            );
1589            text_area
1590        }
1591    }
1592
1593    fn get_text_length(&self) -> u16 {
1594        unsafe { gtk_sys::gtk_entry_get_text_length(self.as_ref().to_glib_none().0) }
1595    }
1596
1597    fn get_visibility(&self) -> bool {
1598        unsafe {
1599            from_glib(gtk_sys::gtk_entry_get_visibility(
1600                self.as_ref().to_glib_none().0,
1601            ))
1602        }
1603    }
1604
1605    fn get_width_chars(&self) -> i32 {
1606        unsafe { gtk_sys::gtk_entry_get_width_chars(self.as_ref().to_glib_none().0) }
1607    }
1608
1609    #[cfg(any(feature = "v3_16", feature = "dox"))]
1610    fn grab_focus_without_selecting(&self) {
1611        unsafe {
1612            gtk_sys::gtk_entry_grab_focus_without_selecting(self.as_ref().to_glib_none().0);
1613        }
1614    }
1615
1616    fn im_context_filter_keypress(&self, event: &gdk::EventKey) -> bool {
1617        unsafe {
1618            from_glib(gtk_sys::gtk_entry_im_context_filter_keypress(
1619                self.as_ref().to_glib_none().0,
1620                mut_override(event.to_glib_none().0),
1621            ))
1622        }
1623    }
1624
1625    fn layout_index_to_text_index(&self, layout_index: i32) -> i32 {
1626        unsafe {
1627            gtk_sys::gtk_entry_layout_index_to_text_index(
1628                self.as_ref().to_glib_none().0,
1629                layout_index,
1630            )
1631        }
1632    }
1633
1634    fn progress_pulse(&self) {
1635        unsafe {
1636            gtk_sys::gtk_entry_progress_pulse(self.as_ref().to_glib_none().0);
1637        }
1638    }
1639
1640    fn reset_im_context(&self) {
1641        unsafe {
1642            gtk_sys::gtk_entry_reset_im_context(self.as_ref().to_glib_none().0);
1643        }
1644    }
1645
1646    fn set_activates_default(&self, setting: bool) {
1647        unsafe {
1648            gtk_sys::gtk_entry_set_activates_default(
1649                self.as_ref().to_glib_none().0,
1650                setting.to_glib(),
1651            );
1652        }
1653    }
1654
1655    fn set_alignment(&self, xalign: f32) {
1656        unsafe {
1657            gtk_sys::gtk_entry_set_alignment(self.as_ref().to_glib_none().0, xalign);
1658        }
1659    }
1660
1661    fn set_attributes(&self, attrs: &pango::AttrList) {
1662        unsafe {
1663            gtk_sys::gtk_entry_set_attributes(
1664                self.as_ref().to_glib_none().0,
1665                attrs.to_glib_none().0,
1666            );
1667        }
1668    }
1669
1670    fn set_buffer<P: IsA<EntryBuffer>>(&self, buffer: &P) {
1671        unsafe {
1672            gtk_sys::gtk_entry_set_buffer(
1673                self.as_ref().to_glib_none().0,
1674                buffer.as_ref().to_glib_none().0,
1675            );
1676        }
1677    }
1678
1679    fn set_completion<P: IsA<EntryCompletion>>(&self, completion: Option<&P>) {
1680        unsafe {
1681            gtk_sys::gtk_entry_set_completion(
1682                self.as_ref().to_glib_none().0,
1683                completion.map(|p| p.as_ref()).to_glib_none().0,
1684            );
1685        }
1686    }
1687
1688    fn set_cursor_hadjustment<P: IsA<Adjustment>>(&self, adjustment: Option<&P>) {
1689        unsafe {
1690            gtk_sys::gtk_entry_set_cursor_hadjustment(
1691                self.as_ref().to_glib_none().0,
1692                adjustment.map(|p| p.as_ref()).to_glib_none().0,
1693            );
1694        }
1695    }
1696
1697    fn set_has_frame(&self, setting: bool) {
1698        unsafe {
1699            gtk_sys::gtk_entry_set_has_frame(self.as_ref().to_glib_none().0, setting.to_glib());
1700        }
1701    }
1702
1703    fn set_icon_activatable(&self, icon_pos: EntryIconPosition, activatable: bool) {
1704        unsafe {
1705            gtk_sys::gtk_entry_set_icon_activatable(
1706                self.as_ref().to_glib_none().0,
1707                icon_pos.to_glib(),
1708                activatable.to_glib(),
1709            );
1710        }
1711    }
1712
1713    fn set_icon_drag_source(
1714        &self,
1715        icon_pos: EntryIconPosition,
1716        target_list: &TargetList,
1717        actions: gdk::DragAction,
1718    ) {
1719        unsafe {
1720            gtk_sys::gtk_entry_set_icon_drag_source(
1721                self.as_ref().to_glib_none().0,
1722                icon_pos.to_glib(),
1723                target_list.to_glib_none().0,
1724                actions.to_glib(),
1725            );
1726        }
1727    }
1728
1729    fn set_icon_from_gicon<P: IsA<gio::Icon>>(
1730        &self,
1731        icon_pos: EntryIconPosition,
1732        icon: Option<&P>,
1733    ) {
1734        unsafe {
1735            gtk_sys::gtk_entry_set_icon_from_gicon(
1736                self.as_ref().to_glib_none().0,
1737                icon_pos.to_glib(),
1738                icon.map(|p| p.as_ref()).to_glib_none().0,
1739            );
1740        }
1741    }
1742
1743    fn set_icon_from_icon_name(&self, icon_pos: EntryIconPosition, icon_name: Option<&str>) {
1744        unsafe {
1745            gtk_sys::gtk_entry_set_icon_from_icon_name(
1746                self.as_ref().to_glib_none().0,
1747                icon_pos.to_glib(),
1748                icon_name.to_glib_none().0,
1749            );
1750        }
1751    }
1752
1753    fn set_icon_from_pixbuf(
1754        &self,
1755        icon_pos: EntryIconPosition,
1756        pixbuf: Option<&gdk_pixbuf::Pixbuf>,
1757    ) {
1758        unsafe {
1759            gtk_sys::gtk_entry_set_icon_from_pixbuf(
1760                self.as_ref().to_glib_none().0,
1761                icon_pos.to_glib(),
1762                pixbuf.to_glib_none().0,
1763            );
1764        }
1765    }
1766
1767    fn set_icon_sensitive(&self, icon_pos: EntryIconPosition, sensitive: bool) {
1768        unsafe {
1769            gtk_sys::gtk_entry_set_icon_sensitive(
1770                self.as_ref().to_glib_none().0,
1771                icon_pos.to_glib(),
1772                sensitive.to_glib(),
1773            );
1774        }
1775    }
1776
1777    fn set_icon_tooltip_markup(&self, icon_pos: EntryIconPosition, tooltip: Option<&str>) {
1778        unsafe {
1779            gtk_sys::gtk_entry_set_icon_tooltip_markup(
1780                self.as_ref().to_glib_none().0,
1781                icon_pos.to_glib(),
1782                tooltip.to_glib_none().0,
1783            );
1784        }
1785    }
1786
1787    fn set_icon_tooltip_text(&self, icon_pos: EntryIconPosition, tooltip: Option<&str>) {
1788        unsafe {
1789            gtk_sys::gtk_entry_set_icon_tooltip_text(
1790                self.as_ref().to_glib_none().0,
1791                icon_pos.to_glib(),
1792                tooltip.to_glib_none().0,
1793            );
1794        }
1795    }
1796
1797    fn set_input_hints(&self, hints: InputHints) {
1798        unsafe {
1799            gtk_sys::gtk_entry_set_input_hints(self.as_ref().to_glib_none().0, hints.to_glib());
1800        }
1801    }
1802
1803    fn set_input_purpose(&self, purpose: InputPurpose) {
1804        unsafe {
1805            gtk_sys::gtk_entry_set_input_purpose(self.as_ref().to_glib_none().0, purpose.to_glib());
1806        }
1807    }
1808
1809    fn set_invisible_char(&self, ch: Option<char>) {
1810        unsafe {
1811            gtk_sys::gtk_entry_set_invisible_char(self.as_ref().to_glib_none().0, ch.to_glib());
1812        }
1813    }
1814
1815    fn set_max_length(&self, max: i32) {
1816        unsafe {
1817            gtk_sys::gtk_entry_set_max_length(self.as_ref().to_glib_none().0, max);
1818        }
1819    }
1820
1821    fn set_max_width_chars(&self, n_chars: i32) {
1822        unsafe {
1823            gtk_sys::gtk_entry_set_max_width_chars(self.as_ref().to_glib_none().0, n_chars);
1824        }
1825    }
1826
1827    fn set_overwrite_mode(&self, overwrite: bool) {
1828        unsafe {
1829            gtk_sys::gtk_entry_set_overwrite_mode(
1830                self.as_ref().to_glib_none().0,
1831                overwrite.to_glib(),
1832            );
1833        }
1834    }
1835
1836    fn set_placeholder_text(&self, text: Option<&str>) {
1837        unsafe {
1838            gtk_sys::gtk_entry_set_placeholder_text(
1839                self.as_ref().to_glib_none().0,
1840                text.to_glib_none().0,
1841            );
1842        }
1843    }
1844
1845    fn set_progress_fraction(&self, fraction: f64) {
1846        unsafe {
1847            gtk_sys::gtk_entry_set_progress_fraction(self.as_ref().to_glib_none().0, fraction);
1848        }
1849    }
1850
1851    fn set_progress_pulse_step(&self, fraction: f64) {
1852        unsafe {
1853            gtk_sys::gtk_entry_set_progress_pulse_step(self.as_ref().to_glib_none().0, fraction);
1854        }
1855    }
1856
1857    fn set_tabs(&self, tabs: &pango::TabArray) {
1858        unsafe {
1859            gtk_sys::gtk_entry_set_tabs(
1860                self.as_ref().to_glib_none().0,
1861                mut_override(tabs.to_glib_none().0),
1862            );
1863        }
1864    }
1865
1866    fn set_text(&self, text: &str) {
1867        unsafe {
1868            gtk_sys::gtk_entry_set_text(self.as_ref().to_glib_none().0, text.to_glib_none().0);
1869        }
1870    }
1871
1872    fn set_visibility(&self, visible: bool) {
1873        unsafe {
1874            gtk_sys::gtk_entry_set_visibility(self.as_ref().to_glib_none().0, visible.to_glib());
1875        }
1876    }
1877
1878    fn set_width_chars(&self, n_chars: i32) {
1879        unsafe {
1880            gtk_sys::gtk_entry_set_width_chars(self.as_ref().to_glib_none().0, n_chars);
1881        }
1882    }
1883
1884    fn text_index_to_layout_index(&self, text_index: i32) -> i32 {
1885        unsafe {
1886            gtk_sys::gtk_entry_text_index_to_layout_index(
1887                self.as_ref().to_glib_none().0,
1888                text_index,
1889            )
1890        }
1891    }
1892
1893    fn unset_invisible_char(&self) {
1894        unsafe {
1895            gtk_sys::gtk_entry_unset_invisible_char(self.as_ref().to_glib_none().0);
1896        }
1897    }
1898
1899    fn get_property_caps_lock_warning(&self) -> bool {
1900        unsafe {
1901            let mut value = Value::from_type(<bool as StaticType>::static_type());
1902            gobject_sys::g_object_get_property(
1903                self.to_glib_none().0 as *mut gobject_sys::GObject,
1904                b"caps-lock-warning\0".as_ptr() as *const _,
1905                value.to_glib_none_mut().0,
1906            );
1907            value.get().unwrap()
1908        }
1909    }
1910
1911    fn set_property_caps_lock_warning(&self, caps_lock_warning: bool) {
1912        unsafe {
1913            gobject_sys::g_object_set_property(
1914                self.to_glib_none().0 as *mut gobject_sys::GObject,
1915                b"caps-lock-warning\0".as_ptr() as *const _,
1916                Value::from(&caps_lock_warning).to_glib_none().0,
1917            );
1918        }
1919    }
1920
1921    fn get_property_cursor_position(&self) -> i32 {
1922        unsafe {
1923            let mut value = Value::from_type(<i32 as StaticType>::static_type());
1924            gobject_sys::g_object_get_property(
1925                self.to_glib_none().0 as *mut gobject_sys::GObject,
1926                b"cursor-position\0".as_ptr() as *const _,
1927                value.to_glib_none_mut().0,
1928            );
1929            value.get().unwrap()
1930        }
1931    }
1932
1933    fn get_property_enable_emoji_completion(&self) -> bool {
1934        unsafe {
1935            let mut value = Value::from_type(<bool as StaticType>::static_type());
1936            gobject_sys::g_object_get_property(
1937                self.to_glib_none().0 as *mut gobject_sys::GObject,
1938                b"enable-emoji-completion\0".as_ptr() as *const _,
1939                value.to_glib_none_mut().0,
1940            );
1941            value.get().unwrap()
1942        }
1943    }
1944
1945    fn set_property_enable_emoji_completion(&self, enable_emoji_completion: bool) {
1946        unsafe {
1947            gobject_sys::g_object_set_property(
1948                self.to_glib_none().0 as *mut gobject_sys::GObject,
1949                b"enable-emoji-completion\0".as_ptr() as *const _,
1950                Value::from(&enable_emoji_completion).to_glib_none().0,
1951            );
1952        }
1953    }
1954
1955    fn get_property_im_module(&self) -> Option<GString> {
1956        unsafe {
1957            let mut value = Value::from_type(<GString as StaticType>::static_type());
1958            gobject_sys::g_object_get_property(
1959                self.to_glib_none().0 as *mut gobject_sys::GObject,
1960                b"im-module\0".as_ptr() as *const _,
1961                value.to_glib_none_mut().0,
1962            );
1963            value.get()
1964        }
1965    }
1966
1967    fn set_property_im_module(&self, im_module: Option<&str>) {
1968        unsafe {
1969            gobject_sys::g_object_set_property(
1970                self.to_glib_none().0 as *mut gobject_sys::GObject,
1971                b"im-module\0".as_ptr() as *const _,
1972                Value::from(im_module).to_glib_none().0,
1973            );
1974        }
1975    }
1976
1977    fn get_property_invisible_char_set(&self) -> bool {
1978        unsafe {
1979            let mut value = Value::from_type(<bool as StaticType>::static_type());
1980            gobject_sys::g_object_get_property(
1981                self.to_glib_none().0 as *mut gobject_sys::GObject,
1982                b"invisible-char-set\0".as_ptr() as *const _,
1983                value.to_glib_none_mut().0,
1984            );
1985            value.get().unwrap()
1986        }
1987    }
1988
1989    fn set_property_invisible_char_set(&self, invisible_char_set: bool) {
1990        unsafe {
1991            gobject_sys::g_object_set_property(
1992                self.to_glib_none().0 as *mut gobject_sys::GObject,
1993                b"invisible-char-set\0".as_ptr() as *const _,
1994                Value::from(&invisible_char_set).to_glib_none().0,
1995            );
1996        }
1997    }
1998
1999    fn get_property_populate_all(&self) -> bool {
2000        unsafe {
2001            let mut value = Value::from_type(<bool as StaticType>::static_type());
2002            gobject_sys::g_object_get_property(
2003                self.to_glib_none().0 as *mut gobject_sys::GObject,
2004                b"populate-all\0".as_ptr() as *const _,
2005                value.to_glib_none_mut().0,
2006            );
2007            value.get().unwrap()
2008        }
2009    }
2010
2011    fn set_property_populate_all(&self, populate_all: bool) {
2012        unsafe {
2013            gobject_sys::g_object_set_property(
2014                self.to_glib_none().0 as *mut gobject_sys::GObject,
2015                b"populate-all\0".as_ptr() as *const _,
2016                Value::from(&populate_all).to_glib_none().0,
2017            );
2018        }
2019    }
2020
2021    fn get_property_primary_icon_activatable(&self) -> bool {
2022        unsafe {
2023            let mut value = Value::from_type(<bool as StaticType>::static_type());
2024            gobject_sys::g_object_get_property(
2025                self.to_glib_none().0 as *mut gobject_sys::GObject,
2026                b"primary-icon-activatable\0".as_ptr() as *const _,
2027                value.to_glib_none_mut().0,
2028            );
2029            value.get().unwrap()
2030        }
2031    }
2032
2033    fn set_property_primary_icon_activatable(&self, primary_icon_activatable: bool) {
2034        unsafe {
2035            gobject_sys::g_object_set_property(
2036                self.to_glib_none().0 as *mut gobject_sys::GObject,
2037                b"primary-icon-activatable\0".as_ptr() as *const _,
2038                Value::from(&primary_icon_activatable).to_glib_none().0,
2039            );
2040        }
2041    }
2042
2043    fn get_property_primary_icon_gicon(&self) -> Option<gio::Icon> {
2044        unsafe {
2045            let mut value = Value::from_type(<gio::Icon as StaticType>::static_type());
2046            gobject_sys::g_object_get_property(
2047                self.to_glib_none().0 as *mut gobject_sys::GObject,
2048                b"primary-icon-gicon\0".as_ptr() as *const _,
2049                value.to_glib_none_mut().0,
2050            );
2051            value.get()
2052        }
2053    }
2054
2055    fn set_property_primary_icon_gicon(&self, primary_icon_gicon: Option<&gio::Icon>) {
2056        unsafe {
2057            gobject_sys::g_object_set_property(
2058                self.to_glib_none().0 as *mut gobject_sys::GObject,
2059                b"primary-icon-gicon\0".as_ptr() as *const _,
2060                Value::from(primary_icon_gicon).to_glib_none().0,
2061            );
2062        }
2063    }
2064
2065    fn get_property_primary_icon_name(&self) -> Option<GString> {
2066        unsafe {
2067            let mut value = Value::from_type(<GString as StaticType>::static_type());
2068            gobject_sys::g_object_get_property(
2069                self.to_glib_none().0 as *mut gobject_sys::GObject,
2070                b"primary-icon-name\0".as_ptr() as *const _,
2071                value.to_glib_none_mut().0,
2072            );
2073            value.get()
2074        }
2075    }
2076
2077    fn set_property_primary_icon_name(&self, primary_icon_name: Option<&str>) {
2078        unsafe {
2079            gobject_sys::g_object_set_property(
2080                self.to_glib_none().0 as *mut gobject_sys::GObject,
2081                b"primary-icon-name\0".as_ptr() as *const _,
2082                Value::from(primary_icon_name).to_glib_none().0,
2083            );
2084        }
2085    }
2086
2087    fn get_property_primary_icon_pixbuf(&self) -> Option<gdk_pixbuf::Pixbuf> {
2088        unsafe {
2089            let mut value = Value::from_type(<gdk_pixbuf::Pixbuf as StaticType>::static_type());
2090            gobject_sys::g_object_get_property(
2091                self.to_glib_none().0 as *mut gobject_sys::GObject,
2092                b"primary-icon-pixbuf\0".as_ptr() as *const _,
2093                value.to_glib_none_mut().0,
2094            );
2095            value.get()
2096        }
2097    }
2098
2099    fn set_property_primary_icon_pixbuf(&self, primary_icon_pixbuf: Option<&gdk_pixbuf::Pixbuf>) {
2100        unsafe {
2101            gobject_sys::g_object_set_property(
2102                self.to_glib_none().0 as *mut gobject_sys::GObject,
2103                b"primary-icon-pixbuf\0".as_ptr() as *const _,
2104                Value::from(primary_icon_pixbuf).to_glib_none().0,
2105            );
2106        }
2107    }
2108
2109    fn get_property_primary_icon_sensitive(&self) -> bool {
2110        unsafe {
2111            let mut value = Value::from_type(<bool as StaticType>::static_type());
2112            gobject_sys::g_object_get_property(
2113                self.to_glib_none().0 as *mut gobject_sys::GObject,
2114                b"primary-icon-sensitive\0".as_ptr() as *const _,
2115                value.to_glib_none_mut().0,
2116            );
2117            value.get().unwrap()
2118        }
2119    }
2120
2121    fn set_property_primary_icon_sensitive(&self, primary_icon_sensitive: bool) {
2122        unsafe {
2123            gobject_sys::g_object_set_property(
2124                self.to_glib_none().0 as *mut gobject_sys::GObject,
2125                b"primary-icon-sensitive\0".as_ptr() as *const _,
2126                Value::from(&primary_icon_sensitive).to_glib_none().0,
2127            );
2128        }
2129    }
2130
2131    fn get_property_primary_icon_storage_type(&self) -> ImageType {
2132        unsafe {
2133            let mut value = Value::from_type(<ImageType as StaticType>::static_type());
2134            gobject_sys::g_object_get_property(
2135                self.to_glib_none().0 as *mut gobject_sys::GObject,
2136                b"primary-icon-storage-type\0".as_ptr() as *const _,
2137                value.to_glib_none_mut().0,
2138            );
2139            value.get().unwrap()
2140        }
2141    }
2142
2143    fn get_property_primary_icon_tooltip_markup(&self) -> Option<GString> {
2144        unsafe {
2145            let mut value = Value::from_type(<GString as StaticType>::static_type());
2146            gobject_sys::g_object_get_property(
2147                self.to_glib_none().0 as *mut gobject_sys::GObject,
2148                b"primary-icon-tooltip-markup\0".as_ptr() as *const _,
2149                value.to_glib_none_mut().0,
2150            );
2151            value.get()
2152        }
2153    }
2154
2155    fn set_property_primary_icon_tooltip_markup(&self, primary_icon_tooltip_markup: Option<&str>) {
2156        unsafe {
2157            gobject_sys::g_object_set_property(
2158                self.to_glib_none().0 as *mut gobject_sys::GObject,
2159                b"primary-icon-tooltip-markup\0".as_ptr() as *const _,
2160                Value::from(primary_icon_tooltip_markup).to_glib_none().0,
2161            );
2162        }
2163    }
2164
2165    fn get_property_primary_icon_tooltip_text(&self) -> Option<GString> {
2166        unsafe {
2167            let mut value = Value::from_type(<GString as StaticType>::static_type());
2168            gobject_sys::g_object_get_property(
2169                self.to_glib_none().0 as *mut gobject_sys::GObject,
2170                b"primary-icon-tooltip-text\0".as_ptr() as *const _,
2171                value.to_glib_none_mut().0,
2172            );
2173            value.get()
2174        }
2175    }
2176
2177    fn set_property_primary_icon_tooltip_text(&self, primary_icon_tooltip_text: Option<&str>) {
2178        unsafe {
2179            gobject_sys::g_object_set_property(
2180                self.to_glib_none().0 as *mut gobject_sys::GObject,
2181                b"primary-icon-tooltip-text\0".as_ptr() as *const _,
2182                Value::from(primary_icon_tooltip_text).to_glib_none().0,
2183            );
2184        }
2185    }
2186
2187    fn get_property_scroll_offset(&self) -> i32 {
2188        unsafe {
2189            let mut value = Value::from_type(<i32 as StaticType>::static_type());
2190            gobject_sys::g_object_get_property(
2191                self.to_glib_none().0 as *mut gobject_sys::GObject,
2192                b"scroll-offset\0".as_ptr() as *const _,
2193                value.to_glib_none_mut().0,
2194            );
2195            value.get().unwrap()
2196        }
2197    }
2198
2199    fn get_property_secondary_icon_activatable(&self) -> bool {
2200        unsafe {
2201            let mut value = Value::from_type(<bool as StaticType>::static_type());
2202            gobject_sys::g_object_get_property(
2203                self.to_glib_none().0 as *mut gobject_sys::GObject,
2204                b"secondary-icon-activatable\0".as_ptr() as *const _,
2205                value.to_glib_none_mut().0,
2206            );
2207            value.get().unwrap()
2208        }
2209    }
2210
2211    fn set_property_secondary_icon_activatable(&self, secondary_icon_activatable: bool) {
2212        unsafe {
2213            gobject_sys::g_object_set_property(
2214                self.to_glib_none().0 as *mut gobject_sys::GObject,
2215                b"secondary-icon-activatable\0".as_ptr() as *const _,
2216                Value::from(&secondary_icon_activatable).to_glib_none().0,
2217            );
2218        }
2219    }
2220
2221    fn get_property_secondary_icon_gicon(&self) -> Option<gio::Icon> {
2222        unsafe {
2223            let mut value = Value::from_type(<gio::Icon as StaticType>::static_type());
2224            gobject_sys::g_object_get_property(
2225                self.to_glib_none().0 as *mut gobject_sys::GObject,
2226                b"secondary-icon-gicon\0".as_ptr() as *const _,
2227                value.to_glib_none_mut().0,
2228            );
2229            value.get()
2230        }
2231    }
2232
2233    fn set_property_secondary_icon_gicon(&self, secondary_icon_gicon: Option<&gio::Icon>) {
2234        unsafe {
2235            gobject_sys::g_object_set_property(
2236                self.to_glib_none().0 as *mut gobject_sys::GObject,
2237                b"secondary-icon-gicon\0".as_ptr() as *const _,
2238                Value::from(secondary_icon_gicon).to_glib_none().0,
2239            );
2240        }
2241    }
2242
2243    fn get_property_secondary_icon_name(&self) -> Option<GString> {
2244        unsafe {
2245            let mut value = Value::from_type(<GString as StaticType>::static_type());
2246            gobject_sys::g_object_get_property(
2247                self.to_glib_none().0 as *mut gobject_sys::GObject,
2248                b"secondary-icon-name\0".as_ptr() as *const _,
2249                value.to_glib_none_mut().0,
2250            );
2251            value.get()
2252        }
2253    }
2254
2255    fn set_property_secondary_icon_name(&self, secondary_icon_name: Option<&str>) {
2256        unsafe {
2257            gobject_sys::g_object_set_property(
2258                self.to_glib_none().0 as *mut gobject_sys::GObject,
2259                b"secondary-icon-name\0".as_ptr() as *const _,
2260                Value::from(secondary_icon_name).to_glib_none().0,
2261            );
2262        }
2263    }
2264
2265    fn get_property_secondary_icon_pixbuf(&self) -> Option<gdk_pixbuf::Pixbuf> {
2266        unsafe {
2267            let mut value = Value::from_type(<gdk_pixbuf::Pixbuf as StaticType>::static_type());
2268            gobject_sys::g_object_get_property(
2269                self.to_glib_none().0 as *mut gobject_sys::GObject,
2270                b"secondary-icon-pixbuf\0".as_ptr() as *const _,
2271                value.to_glib_none_mut().0,
2272            );
2273            value.get()
2274        }
2275    }
2276
2277    fn set_property_secondary_icon_pixbuf(
2278        &self,
2279        secondary_icon_pixbuf: Option<&gdk_pixbuf::Pixbuf>,
2280    ) {
2281        unsafe {
2282            gobject_sys::g_object_set_property(
2283                self.to_glib_none().0 as *mut gobject_sys::GObject,
2284                b"secondary-icon-pixbuf\0".as_ptr() as *const _,
2285                Value::from(secondary_icon_pixbuf).to_glib_none().0,
2286            );
2287        }
2288    }
2289
2290    fn get_property_secondary_icon_sensitive(&self) -> bool {
2291        unsafe {
2292            let mut value = Value::from_type(<bool as StaticType>::static_type());
2293            gobject_sys::g_object_get_property(
2294                self.to_glib_none().0 as *mut gobject_sys::GObject,
2295                b"secondary-icon-sensitive\0".as_ptr() as *const _,
2296                value.to_glib_none_mut().0,
2297            );
2298            value.get().unwrap()
2299        }
2300    }
2301
2302    fn set_property_secondary_icon_sensitive(&self, secondary_icon_sensitive: bool) {
2303        unsafe {
2304            gobject_sys::g_object_set_property(
2305                self.to_glib_none().0 as *mut gobject_sys::GObject,
2306                b"secondary-icon-sensitive\0".as_ptr() as *const _,
2307                Value::from(&secondary_icon_sensitive).to_glib_none().0,
2308            );
2309        }
2310    }
2311
2312    fn get_property_secondary_icon_storage_type(&self) -> ImageType {
2313        unsafe {
2314            let mut value = Value::from_type(<ImageType as StaticType>::static_type());
2315            gobject_sys::g_object_get_property(
2316                self.to_glib_none().0 as *mut gobject_sys::GObject,
2317                b"secondary-icon-storage-type\0".as_ptr() as *const _,
2318                value.to_glib_none_mut().0,
2319            );
2320            value.get().unwrap()
2321        }
2322    }
2323
2324    fn get_property_secondary_icon_tooltip_markup(&self) -> Option<GString> {
2325        unsafe {
2326            let mut value = Value::from_type(<GString as StaticType>::static_type());
2327            gobject_sys::g_object_get_property(
2328                self.to_glib_none().0 as *mut gobject_sys::GObject,
2329                b"secondary-icon-tooltip-markup\0".as_ptr() as *const _,
2330                value.to_glib_none_mut().0,
2331            );
2332            value.get()
2333        }
2334    }
2335
2336    fn set_property_secondary_icon_tooltip_markup(
2337        &self,
2338        secondary_icon_tooltip_markup: Option<&str>,
2339    ) {
2340        unsafe {
2341            gobject_sys::g_object_set_property(
2342                self.to_glib_none().0 as *mut gobject_sys::GObject,
2343                b"secondary-icon-tooltip-markup\0".as_ptr() as *const _,
2344                Value::from(secondary_icon_tooltip_markup).to_glib_none().0,
2345            );
2346        }
2347    }
2348
2349    fn get_property_secondary_icon_tooltip_text(&self) -> Option<GString> {
2350        unsafe {
2351            let mut value = Value::from_type(<GString as StaticType>::static_type());
2352            gobject_sys::g_object_get_property(
2353                self.to_glib_none().0 as *mut gobject_sys::GObject,
2354                b"secondary-icon-tooltip-text\0".as_ptr() as *const _,
2355                value.to_glib_none_mut().0,
2356            );
2357            value.get()
2358        }
2359    }
2360
2361    fn set_property_secondary_icon_tooltip_text(&self, secondary_icon_tooltip_text: Option<&str>) {
2362        unsafe {
2363            gobject_sys::g_object_set_property(
2364                self.to_glib_none().0 as *mut gobject_sys::GObject,
2365                b"secondary-icon-tooltip-text\0".as_ptr() as *const _,
2366                Value::from(secondary_icon_tooltip_text).to_glib_none().0,
2367            );
2368        }
2369    }
2370
2371    fn get_property_selection_bound(&self) -> i32 {
2372        unsafe {
2373            let mut value = Value::from_type(<i32 as StaticType>::static_type());
2374            gobject_sys::g_object_get_property(
2375                self.to_glib_none().0 as *mut gobject_sys::GObject,
2376                b"selection-bound\0".as_ptr() as *const _,
2377                value.to_glib_none_mut().0,
2378            );
2379            value.get().unwrap()
2380        }
2381    }
2382
2383    fn get_property_shadow_type(&self) -> ShadowType {
2384        unsafe {
2385            let mut value = Value::from_type(<ShadowType as StaticType>::static_type());
2386            gobject_sys::g_object_get_property(
2387                self.to_glib_none().0 as *mut gobject_sys::GObject,
2388                b"shadow-type\0".as_ptr() as *const _,
2389                value.to_glib_none_mut().0,
2390            );
2391            value.get().unwrap()
2392        }
2393    }
2394
2395    fn set_property_shadow_type(&self, shadow_type: ShadowType) {
2396        unsafe {
2397            gobject_sys::g_object_set_property(
2398                self.to_glib_none().0 as *mut gobject_sys::GObject,
2399                b"shadow-type\0".as_ptr() as *const _,
2400                Value::from(&shadow_type).to_glib_none().0,
2401            );
2402        }
2403    }
2404
2405    fn get_property_show_emoji_icon(&self) -> bool {
2406        unsafe {
2407            let mut value = Value::from_type(<bool as StaticType>::static_type());
2408            gobject_sys::g_object_get_property(
2409                self.to_glib_none().0 as *mut gobject_sys::GObject,
2410                b"show-emoji-icon\0".as_ptr() as *const _,
2411                value.to_glib_none_mut().0,
2412            );
2413            value.get().unwrap()
2414        }
2415    }
2416
2417    fn set_property_show_emoji_icon(&self, show_emoji_icon: bool) {
2418        unsafe {
2419            gobject_sys::g_object_set_property(
2420                self.to_glib_none().0 as *mut gobject_sys::GObject,
2421                b"show-emoji-icon\0".as_ptr() as *const _,
2422                Value::from(&show_emoji_icon).to_glib_none().0,
2423            );
2424        }
2425    }
2426
2427    fn get_property_truncate_multiline(&self) -> bool {
2428        unsafe {
2429            let mut value = Value::from_type(<bool as StaticType>::static_type());
2430            gobject_sys::g_object_get_property(
2431                self.to_glib_none().0 as *mut gobject_sys::GObject,
2432                b"truncate-multiline\0".as_ptr() as *const _,
2433                value.to_glib_none_mut().0,
2434            );
2435            value.get().unwrap()
2436        }
2437    }
2438
2439    fn set_property_truncate_multiline(&self, truncate_multiline: bool) {
2440        unsafe {
2441            gobject_sys::g_object_set_property(
2442                self.to_glib_none().0 as *mut gobject_sys::GObject,
2443                b"truncate-multiline\0".as_ptr() as *const _,
2444                Value::from(&truncate_multiline).to_glib_none().0,
2445            );
2446        }
2447    }
2448
2449    fn get_property_xalign(&self) -> f32 {
2450        unsafe {
2451            let mut value = Value::from_type(<f32 as StaticType>::static_type());
2452            gobject_sys::g_object_get_property(
2453                self.to_glib_none().0 as *mut gobject_sys::GObject,
2454                b"xalign\0".as_ptr() as *const _,
2455                value.to_glib_none_mut().0,
2456            );
2457            value.get().unwrap()
2458        }
2459    }
2460
2461    fn set_property_xalign(&self, xalign: f32) {
2462        unsafe {
2463            gobject_sys::g_object_set_property(
2464                self.to_glib_none().0 as *mut gobject_sys::GObject,
2465                b"xalign\0".as_ptr() as *const _,
2466                Value::from(&xalign).to_glib_none().0,
2467            );
2468        }
2469    }
2470
2471    fn connect_activate<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
2472        unsafe extern "C" fn activate_trampoline<P, F: Fn(&P) + 'static>(
2473            this: *mut gtk_sys::GtkEntry,
2474            f: glib_sys::gpointer,
2475        ) where
2476            P: IsA<Entry>,
2477        {
2478            let f: &F = &*(f as *const F);
2479            f(&Entry::from_glib_borrow(this).unsafe_cast())
2480        }
2481        unsafe {
2482            let f: Box_<F> = Box_::new(f);
2483            connect_raw(
2484                self.as_ptr() as *mut _,
2485                b"activate\0".as_ptr() as *const _,
2486                Some(transmute(activate_trampoline::<Self, F> as usize)),
2487                Box_::into_raw(f),
2488            )
2489        }
2490    }
2491
2492    fn emit_activate(&self) {
2493        let _ = unsafe {
2494            glib::Object::from_glib_borrow(self.to_glib_none().0 as *mut gobject_sys::GObject)
2495                .emit("activate", &[])
2496                .unwrap()
2497        };
2498    }
2499
2500    fn connect_backspace<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
2501        unsafe extern "C" fn backspace_trampoline<P, F: Fn(&P) + 'static>(
2502            this: *mut gtk_sys::GtkEntry,
2503            f: glib_sys::gpointer,
2504        ) where
2505            P: IsA<Entry>,
2506        {
2507            let f: &F = &*(f as *const F);
2508            f(&Entry::from_glib_borrow(this).unsafe_cast())
2509        }
2510        unsafe {
2511            let f: Box_<F> = Box_::new(f);
2512            connect_raw(
2513                self.as_ptr() as *mut _,
2514                b"backspace\0".as_ptr() as *const _,
2515                Some(transmute(backspace_trampoline::<Self, F> as usize)),
2516                Box_::into_raw(f),
2517            )
2518        }
2519    }
2520
2521    fn emit_backspace(&self) {
2522        let _ = unsafe {
2523            glib::Object::from_glib_borrow(self.to_glib_none().0 as *mut gobject_sys::GObject)
2524                .emit("backspace", &[])
2525                .unwrap()
2526        };
2527    }
2528
2529    fn connect_copy_clipboard<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
2530        unsafe extern "C" fn copy_clipboard_trampoline<P, F: Fn(&P) + 'static>(
2531            this: *mut gtk_sys::GtkEntry,
2532            f: glib_sys::gpointer,
2533        ) where
2534            P: IsA<Entry>,
2535        {
2536            let f: &F = &*(f as *const F);
2537            f(&Entry::from_glib_borrow(this).unsafe_cast())
2538        }
2539        unsafe {
2540            let f: Box_<F> = Box_::new(f);
2541            connect_raw(
2542                self.as_ptr() as *mut _,
2543                b"copy-clipboard\0".as_ptr() as *const _,
2544                Some(transmute(copy_clipboard_trampoline::<Self, F> as usize)),
2545                Box_::into_raw(f),
2546            )
2547        }
2548    }
2549
2550    fn emit_copy_clipboard(&self) {
2551        let _ = unsafe {
2552            glib::Object::from_glib_borrow(self.to_glib_none().0 as *mut gobject_sys::GObject)
2553                .emit("copy-clipboard", &[])
2554                .unwrap()
2555        };
2556    }
2557
2558    fn connect_cut_clipboard<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
2559        unsafe extern "C" fn cut_clipboard_trampoline<P, F: Fn(&P) + 'static>(
2560            this: *mut gtk_sys::GtkEntry,
2561            f: glib_sys::gpointer,
2562        ) where
2563            P: IsA<Entry>,
2564        {
2565            let f: &F = &*(f as *const F);
2566            f(&Entry::from_glib_borrow(this).unsafe_cast())
2567        }
2568        unsafe {
2569            let f: Box_<F> = Box_::new(f);
2570            connect_raw(
2571                self.as_ptr() as *mut _,
2572                b"cut-clipboard\0".as_ptr() as *const _,
2573                Some(transmute(cut_clipboard_trampoline::<Self, F> as usize)),
2574                Box_::into_raw(f),
2575            )
2576        }
2577    }
2578
2579    fn emit_cut_clipboard(&self) {
2580        let _ = unsafe {
2581            glib::Object::from_glib_borrow(self.to_glib_none().0 as *mut gobject_sys::GObject)
2582                .emit("cut-clipboard", &[])
2583                .unwrap()
2584        };
2585    }
2586
2587    fn connect_delete_from_cursor<F: Fn(&Self, DeleteType, i32) + 'static>(
2588        &self,
2589        f: F,
2590    ) -> SignalHandlerId {
2591        unsafe extern "C" fn delete_from_cursor_trampoline<
2592            P,
2593            F: Fn(&P, DeleteType, i32) + 'static,
2594        >(
2595            this: *mut gtk_sys::GtkEntry,
2596            type_: gtk_sys::GtkDeleteType,
2597            count: libc::c_int,
2598            f: glib_sys::gpointer,
2599        ) where
2600            P: IsA<Entry>,
2601        {
2602            let f: &F = &*(f as *const F);
2603            f(
2604                &Entry::from_glib_borrow(this).unsafe_cast(),
2605                from_glib(type_),
2606                count,
2607            )
2608        }
2609        unsafe {
2610            let f: Box_<F> = Box_::new(f);
2611            connect_raw(
2612                self.as_ptr() as *mut _,
2613                b"delete-from-cursor\0".as_ptr() as *const _,
2614                Some(transmute(delete_from_cursor_trampoline::<Self, F> as usize)),
2615                Box_::into_raw(f),
2616            )
2617        }
2618    }
2619
2620    fn emit_delete_from_cursor(&self, type_: DeleteType, count: i32) {
2621        let _ = unsafe {
2622            glib::Object::from_glib_borrow(self.to_glib_none().0 as *mut gobject_sys::GObject)
2623                .emit("delete-from-cursor", &[&type_, &count])
2624                .unwrap()
2625        };
2626    }
2627
2628    fn connect_icon_press<F: Fn(&Self, EntryIconPosition, &gdk::EventButton) + 'static>(
2629        &self,
2630        f: F,
2631    ) -> SignalHandlerId {
2632        unsafe extern "C" fn icon_press_trampoline<
2633            P,
2634            F: Fn(&P, EntryIconPosition, &gdk::EventButton) + 'static,
2635        >(
2636            this: *mut gtk_sys::GtkEntry,
2637            icon_pos: gtk_sys::GtkEntryIconPosition,
2638            event: *mut gdk_sys::GdkEventButton,
2639            f: glib_sys::gpointer,
2640        ) where
2641            P: IsA<Entry>,
2642        {
2643            let f: &F = &*(f as *const F);
2644            f(
2645                &Entry::from_glib_borrow(this).unsafe_cast(),
2646                from_glib(icon_pos),
2647                &from_glib_borrow(event),
2648            )
2649        }
2650        unsafe {
2651            let f: Box_<F> = Box_::new(f);
2652            connect_raw(
2653                self.as_ptr() as *mut _,
2654                b"icon-press\0".as_ptr() as *const _,
2655                Some(transmute(icon_press_trampoline::<Self, F> as usize)),
2656                Box_::into_raw(f),
2657            )
2658        }
2659    }
2660
2661    fn connect_icon_release<F: Fn(&Self, EntryIconPosition, &gdk::EventButton) + 'static>(
2662        &self,
2663        f: F,
2664    ) -> SignalHandlerId {
2665        unsafe extern "C" fn icon_release_trampoline<
2666            P,
2667            F: Fn(&P, EntryIconPosition, &gdk::EventButton) + 'static,
2668        >(
2669            this: *mut gtk_sys::GtkEntry,
2670            icon_pos: gtk_sys::GtkEntryIconPosition,
2671            event: *mut gdk_sys::GdkEventButton,
2672            f: glib_sys::gpointer,
2673        ) where
2674            P: IsA<Entry>,
2675        {
2676            let f: &F = &*(f as *const F);
2677            f(
2678                &Entry::from_glib_borrow(this).unsafe_cast(),
2679                from_glib(icon_pos),
2680                &from_glib_borrow(event),
2681            )
2682        }
2683        unsafe {
2684            let f: Box_<F> = Box_::new(f);
2685            connect_raw(
2686                self.as_ptr() as *mut _,
2687                b"icon-release\0".as_ptr() as *const _,
2688                Some(transmute(icon_release_trampoline::<Self, F> as usize)),
2689                Box_::into_raw(f),
2690            )
2691        }
2692    }
2693
2694    fn connect_insert_at_cursor<F: Fn(&Self, &str) + 'static>(&self, f: F) -> SignalHandlerId {
2695        unsafe extern "C" fn insert_at_cursor_trampoline<P, F: Fn(&P, &str) + 'static>(
2696            this: *mut gtk_sys::GtkEntry,
2697            string: *mut libc::c_char,
2698            f: glib_sys::gpointer,
2699        ) where
2700            P: IsA<Entry>,
2701        {
2702            let f: &F = &*(f as *const F);
2703            f(
2704                &Entry::from_glib_borrow(this).unsafe_cast(),
2705                &GString::from_glib_borrow(string),
2706            )
2707        }
2708        unsafe {
2709            let f: Box_<F> = Box_::new(f);
2710            connect_raw(
2711                self.as_ptr() as *mut _,
2712                b"insert-at-cursor\0".as_ptr() as *const _,
2713                Some(transmute(insert_at_cursor_trampoline::<Self, F> as usize)),
2714                Box_::into_raw(f),
2715            )
2716        }
2717    }
2718
2719    fn emit_insert_at_cursor(&self, string: &str) {
2720        let _ = unsafe {
2721            glib::Object::from_glib_borrow(self.to_glib_none().0 as *mut gobject_sys::GObject)
2722                .emit("insert-at-cursor", &[&string])
2723                .unwrap()
2724        };
2725    }
2726
2727    #[cfg(any(feature = "v3_22_27", feature = "dox"))]
2728    fn connect_insert_emoji<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
2729        unsafe extern "C" fn insert_emoji_trampoline<P, F: Fn(&P) + 'static>(
2730            this: *mut gtk_sys::GtkEntry,
2731            f: glib_sys::gpointer,
2732        ) where
2733            P: IsA<Entry>,
2734        {
2735            let f: &F = &*(f as *const F);
2736            f(&Entry::from_glib_borrow(this).unsafe_cast())
2737        }
2738        unsafe {
2739            let f: Box_<F> = Box_::new(f);
2740            connect_raw(
2741                self.as_ptr() as *mut _,
2742                b"insert-emoji\0".as_ptr() as *const _,
2743                Some(transmute(insert_emoji_trampoline::<Self, F> as usize)),
2744                Box_::into_raw(f),
2745            )
2746        }
2747    }
2748
2749    #[cfg(any(feature = "v3_22_27", feature = "dox"))]
2750    fn emit_insert_emoji(&self) {
2751        let _ = unsafe {
2752            glib::Object::from_glib_borrow(self.to_glib_none().0 as *mut gobject_sys::GObject)
2753                .emit("insert-emoji", &[])
2754                .unwrap()
2755        };
2756    }
2757
2758    fn connect_move_cursor<F: Fn(&Self, MovementStep, i32, bool) + 'static>(
2759        &self,
2760        f: F,
2761    ) -> SignalHandlerId {
2762        unsafe extern "C" fn move_cursor_trampoline<
2763            P,
2764            F: Fn(&P, MovementStep, i32, bool) + 'static,
2765        >(
2766            this: *mut gtk_sys::GtkEntry,
2767            step: gtk_sys::GtkMovementStep,
2768            count: libc::c_int,
2769            extend_selection: glib_sys::gboolean,
2770            f: glib_sys::gpointer,
2771        ) where
2772            P: IsA<Entry>,
2773        {
2774            let f: &F = &*(f as *const F);
2775            f(
2776                &Entry::from_glib_borrow(this).unsafe_cast(),
2777                from_glib(step),
2778                count,
2779                from_glib(extend_selection),
2780            )
2781        }
2782        unsafe {
2783            let f: Box_<F> = Box_::new(f);
2784            connect_raw(
2785                self.as_ptr() as *mut _,
2786                b"move-cursor\0".as_ptr() as *const _,
2787                Some(transmute(move_cursor_trampoline::<Self, F> as usize)),
2788                Box_::into_raw(f),
2789            )
2790        }
2791    }
2792
2793    fn emit_move_cursor(&self, step: MovementStep, count: i32, extend_selection: bool) {
2794        let _ = unsafe {
2795            glib::Object::from_glib_borrow(self.to_glib_none().0 as *mut gobject_sys::GObject)
2796                .emit("move-cursor", &[&step, &count, &extend_selection])
2797                .unwrap()
2798        };
2799    }
2800
2801    fn connect_paste_clipboard<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
2802        unsafe extern "C" fn paste_clipboard_trampoline<P, F: Fn(&P) + 'static>(
2803            this: *mut gtk_sys::GtkEntry,
2804            f: glib_sys::gpointer,
2805        ) where
2806            P: IsA<Entry>,
2807        {
2808            let f: &F = &*(f as *const F);
2809            f(&Entry::from_glib_borrow(this).unsafe_cast())
2810        }
2811        unsafe {
2812            let f: Box_<F> = Box_::new(f);
2813            connect_raw(
2814                self.as_ptr() as *mut _,
2815                b"paste-clipboard\0".as_ptr() as *const _,
2816                Some(transmute(paste_clipboard_trampoline::<Self, F> as usize)),
2817                Box_::into_raw(f),
2818            )
2819        }
2820    }
2821
2822    fn emit_paste_clipboard(&self) {
2823        let _ = unsafe {
2824            glib::Object::from_glib_borrow(self.to_glib_none().0 as *mut gobject_sys::GObject)
2825                .emit("paste-clipboard", &[])
2826                .unwrap()
2827        };
2828    }
2829
2830    fn connect_populate_popup<F: Fn(&Self, &Widget) + 'static>(&self, f: F) -> SignalHandlerId {
2831        unsafe extern "C" fn populate_popup_trampoline<P, F: Fn(&P, &Widget) + 'static>(
2832            this: *mut gtk_sys::GtkEntry,
2833            widget: *mut gtk_sys::GtkWidget,
2834            f: glib_sys::gpointer,
2835        ) where
2836            P: IsA<Entry>,
2837        {
2838            let f: &F = &*(f as *const F);
2839            f(
2840                &Entry::from_glib_borrow(this).unsafe_cast(),
2841                &from_glib_borrow(widget),
2842            )
2843        }
2844        unsafe {
2845            let f: Box_<F> = Box_::new(f);
2846            connect_raw(
2847                self.as_ptr() as *mut _,
2848                b"populate-popup\0".as_ptr() as *const _,
2849                Some(transmute(populate_popup_trampoline::<Self, F> as usize)),
2850                Box_::into_raw(f),
2851            )
2852        }
2853    }
2854
2855    fn connect_preedit_changed<F: Fn(&Self, &str) + 'static>(&self, f: F) -> SignalHandlerId {
2856        unsafe extern "C" fn preedit_changed_trampoline<P, F: Fn(&P, &str) + 'static>(
2857            this: *mut gtk_sys::GtkEntry,
2858            preedit: *mut libc::c_char,
2859            f: glib_sys::gpointer,
2860        ) where
2861            P: IsA<Entry>,
2862        {
2863            let f: &F = &*(f as *const F);
2864            f(
2865                &Entry::from_glib_borrow(this).unsafe_cast(),
2866                &GString::from_glib_borrow(preedit),
2867            )
2868        }
2869        unsafe {
2870            let f: Box_<F> = Box_::new(f);
2871            connect_raw(
2872                self.as_ptr() as *mut _,
2873                b"preedit-changed\0".as_ptr() as *const _,
2874                Some(transmute(preedit_changed_trampoline::<Self, F> as usize)),
2875                Box_::into_raw(f),
2876            )
2877        }
2878    }
2879
2880    fn emit_preedit_changed(&self, preedit: &str) {
2881        let _ = unsafe {
2882            glib::Object::from_glib_borrow(self.to_glib_none().0 as *mut gobject_sys::GObject)
2883                .emit("preedit-changed", &[&preedit])
2884                .unwrap()
2885        };
2886    }
2887
2888    fn connect_toggle_overwrite<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
2889        unsafe extern "C" fn toggle_overwrite_trampoline<P, F: Fn(&P) + 'static>(
2890            this: *mut gtk_sys::GtkEntry,
2891            f: glib_sys::gpointer,
2892        ) where
2893            P: IsA<Entry>,
2894        {
2895            let f: &F = &*(f as *const F);
2896            f(&Entry::from_glib_borrow(this).unsafe_cast())
2897        }
2898        unsafe {
2899            let f: Box_<F> = Box_::new(f);
2900            connect_raw(
2901                self.as_ptr() as *mut _,
2902                b"toggle-overwrite\0".as_ptr() as *const _,
2903                Some(transmute(toggle_overwrite_trampoline::<Self, F> as usize)),
2904                Box_::into_raw(f),
2905            )
2906        }
2907    }
2908
2909    fn emit_toggle_overwrite(&self) {
2910        let _ = unsafe {
2911            glib::Object::from_glib_borrow(self.to_glib_none().0 as *mut gobject_sys::GObject)
2912                .emit("toggle-overwrite", &[])
2913                .unwrap()
2914        };
2915    }
2916
2917    fn connect_property_activates_default_notify<F: Fn(&Self) + 'static>(
2918        &self,
2919        f: F,
2920    ) -> SignalHandlerId {
2921        unsafe extern "C" fn notify_activates_default_trampoline<P, F: Fn(&P) + 'static>(
2922            this: *mut gtk_sys::GtkEntry,
2923            _param_spec: glib_sys::gpointer,
2924            f: glib_sys::gpointer,
2925        ) where
2926            P: IsA<Entry>,
2927        {
2928            let f: &F = &*(f as *const F);
2929            f(&Entry::from_glib_borrow(this).unsafe_cast())
2930        }
2931        unsafe {
2932            let f: Box_<F> = Box_::new(f);
2933            connect_raw(
2934                self.as_ptr() as *mut _,
2935                b"notify::activates-default\0".as_ptr() as *const _,
2936                Some(transmute(
2937                    notify_activates_default_trampoline::<Self, F> as usize,
2938                )),
2939                Box_::into_raw(f),
2940            )
2941        }
2942    }
2943
2944    fn connect_property_attributes_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
2945        unsafe extern "C" fn notify_attributes_trampoline<P, F: Fn(&P) + 'static>(
2946            this: *mut gtk_sys::GtkEntry,
2947            _param_spec: glib_sys::gpointer,
2948            f: glib_sys::gpointer,
2949        ) where
2950            P: IsA<Entry>,
2951        {
2952            let f: &F = &*(f as *const F);
2953            f(&Entry::from_glib_borrow(this).unsafe_cast())
2954        }
2955        unsafe {
2956            let f: Box_<F> = Box_::new(f);
2957            connect_raw(
2958                self.as_ptr() as *mut _,
2959                b"notify::attributes\0".as_ptr() as *const _,
2960                Some(transmute(notify_attributes_trampoline::<Self, F> as usize)),
2961                Box_::into_raw(f),
2962            )
2963        }
2964    }
2965
2966    fn connect_property_buffer_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
2967        unsafe extern "C" fn notify_buffer_trampoline<P, F: Fn(&P) + 'static>(
2968            this: *mut gtk_sys::GtkEntry,
2969            _param_spec: glib_sys::gpointer,
2970            f: glib_sys::gpointer,
2971        ) where
2972            P: IsA<Entry>,
2973        {
2974            let f: &F = &*(f as *const F);
2975            f(&Entry::from_glib_borrow(this).unsafe_cast())
2976        }
2977        unsafe {
2978            let f: Box_<F> = Box_::new(f);
2979            connect_raw(
2980                self.as_ptr() as *mut _,
2981                b"notify::buffer\0".as_ptr() as *const _,
2982                Some(transmute(notify_buffer_trampoline::<Self, F> as usize)),
2983                Box_::into_raw(f),
2984            )
2985        }
2986    }
2987
2988    fn connect_property_caps_lock_warning_notify<F: Fn(&Self) + 'static>(
2989        &self,
2990        f: F,
2991    ) -> SignalHandlerId {
2992        unsafe extern "C" fn notify_caps_lock_warning_trampoline<P, F: Fn(&P) + 'static>(
2993            this: *mut gtk_sys::GtkEntry,
2994            _param_spec: glib_sys::gpointer,
2995            f: glib_sys::gpointer,
2996        ) where
2997            P: IsA<Entry>,
2998        {
2999            let f: &F = &*(f as *const F);
3000            f(&Entry::from_glib_borrow(this).unsafe_cast())
3001        }
3002        unsafe {
3003            let f: Box_<F> = Box_::new(f);
3004            connect_raw(
3005                self.as_ptr() as *mut _,
3006                b"notify::caps-lock-warning\0".as_ptr() as *const _,
3007                Some(transmute(
3008                    notify_caps_lock_warning_trampoline::<Self, F> as usize,
3009                )),
3010                Box_::into_raw(f),
3011            )
3012        }
3013    }
3014
3015    fn connect_property_completion_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3016        unsafe extern "C" fn notify_completion_trampoline<P, F: Fn(&P) + 'static>(
3017            this: *mut gtk_sys::GtkEntry,
3018            _param_spec: glib_sys::gpointer,
3019            f: glib_sys::gpointer,
3020        ) where
3021            P: IsA<Entry>,
3022        {
3023            let f: &F = &*(f as *const F);
3024            f(&Entry::from_glib_borrow(this).unsafe_cast())
3025        }
3026        unsafe {
3027            let f: Box_<F> = Box_::new(f);
3028            connect_raw(
3029                self.as_ptr() as *mut _,
3030                b"notify::completion\0".as_ptr() as *const _,
3031                Some(transmute(notify_completion_trampoline::<Self, F> as usize)),
3032                Box_::into_raw(f),
3033            )
3034        }
3035    }
3036
3037    fn connect_property_cursor_position_notify<F: Fn(&Self) + 'static>(
3038        &self,
3039        f: F,
3040    ) -> SignalHandlerId {
3041        unsafe extern "C" fn notify_cursor_position_trampoline<P, F: Fn(&P) + 'static>(
3042            this: *mut gtk_sys::GtkEntry,
3043            _param_spec: glib_sys::gpointer,
3044            f: glib_sys::gpointer,
3045        ) where
3046            P: IsA<Entry>,
3047        {
3048            let f: &F = &*(f as *const F);
3049            f(&Entry::from_glib_borrow(this).unsafe_cast())
3050        }
3051        unsafe {
3052            let f: Box_<F> = Box_::new(f);
3053            connect_raw(
3054                self.as_ptr() as *mut _,
3055                b"notify::cursor-position\0".as_ptr() as *const _,
3056                Some(transmute(
3057                    notify_cursor_position_trampoline::<Self, F> as usize,
3058                )),
3059                Box_::into_raw(f),
3060            )
3061        }
3062    }
3063
3064    fn connect_property_editable_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3065        unsafe extern "C" fn notify_editable_trampoline<P, F: Fn(&P) + 'static>(
3066            this: *mut gtk_sys::GtkEntry,
3067            _param_spec: glib_sys::gpointer,
3068            f: glib_sys::gpointer,
3069        ) where
3070            P: IsA<Entry>,
3071        {
3072            let f: &F = &*(f as *const F);
3073            f(&Entry::from_glib_borrow(this).unsafe_cast())
3074        }
3075        unsafe {
3076            let f: Box_<F> = Box_::new(f);
3077            connect_raw(
3078                self.as_ptr() as *mut _,
3079                b"notify::editable\0".as_ptr() as *const _,
3080                Some(transmute(notify_editable_trampoline::<Self, F> as usize)),
3081                Box_::into_raw(f),
3082            )
3083        }
3084    }
3085
3086    fn connect_property_enable_emoji_completion_notify<F: Fn(&Self) + 'static>(
3087        &self,
3088        f: F,
3089    ) -> SignalHandlerId {
3090        unsafe extern "C" fn notify_enable_emoji_completion_trampoline<P, F: Fn(&P) + 'static>(
3091            this: *mut gtk_sys::GtkEntry,
3092            _param_spec: glib_sys::gpointer,
3093            f: glib_sys::gpointer,
3094        ) where
3095            P: IsA<Entry>,
3096        {
3097            let f: &F = &*(f as *const F);
3098            f(&Entry::from_glib_borrow(this).unsafe_cast())
3099        }
3100        unsafe {
3101            let f: Box_<F> = Box_::new(f);
3102            connect_raw(
3103                self.as_ptr() as *mut _,
3104                b"notify::enable-emoji-completion\0".as_ptr() as *const _,
3105                Some(transmute(
3106                    notify_enable_emoji_completion_trampoline::<Self, F> as usize,
3107                )),
3108                Box_::into_raw(f),
3109            )
3110        }
3111    }
3112
3113    fn connect_property_has_frame_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3114        unsafe extern "C" fn notify_has_frame_trampoline<P, F: Fn(&P) + 'static>(
3115            this: *mut gtk_sys::GtkEntry,
3116            _param_spec: glib_sys::gpointer,
3117            f: glib_sys::gpointer,
3118        ) where
3119            P: IsA<Entry>,
3120        {
3121            let f: &F = &*(f as *const F);
3122            f(&Entry::from_glib_borrow(this).unsafe_cast())
3123        }
3124        unsafe {
3125            let f: Box_<F> = Box_::new(f);
3126            connect_raw(
3127                self.as_ptr() as *mut _,
3128                b"notify::has-frame\0".as_ptr() as *const _,
3129                Some(transmute(notify_has_frame_trampoline::<Self, F> as usize)),
3130                Box_::into_raw(f),
3131            )
3132        }
3133    }
3134
3135    fn connect_property_im_module_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3136        unsafe extern "C" fn notify_im_module_trampoline<P, F: Fn(&P) + 'static>(
3137            this: *mut gtk_sys::GtkEntry,
3138            _param_spec: glib_sys::gpointer,
3139            f: glib_sys::gpointer,
3140        ) where
3141            P: IsA<Entry>,
3142        {
3143            let f: &F = &*(f as *const F);
3144            f(&Entry::from_glib_borrow(this).unsafe_cast())
3145        }
3146        unsafe {
3147            let f: Box_<F> = Box_::new(f);
3148            connect_raw(
3149                self.as_ptr() as *mut _,
3150                b"notify::im-module\0".as_ptr() as *const _,
3151                Some(transmute(notify_im_module_trampoline::<Self, F> as usize)),
3152                Box_::into_raw(f),
3153            )
3154        }
3155    }
3156
3157    fn connect_property_input_hints_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3158        unsafe extern "C" fn notify_input_hints_trampoline<P, F: Fn(&P) + 'static>(
3159            this: *mut gtk_sys::GtkEntry,
3160            _param_spec: glib_sys::gpointer,
3161            f: glib_sys::gpointer,
3162        ) where
3163            P: IsA<Entry>,
3164        {
3165            let f: &F = &*(f as *const F);
3166            f(&Entry::from_glib_borrow(this).unsafe_cast())
3167        }
3168        unsafe {
3169            let f: Box_<F> = Box_::new(f);
3170            connect_raw(
3171                self.as_ptr() as *mut _,
3172                b"notify::input-hints\0".as_ptr() as *const _,
3173                Some(transmute(notify_input_hints_trampoline::<Self, F> as usize)),
3174                Box_::into_raw(f),
3175            )
3176        }
3177    }
3178
3179    fn connect_property_input_purpose_notify<F: Fn(&Self) + 'static>(
3180        &self,
3181        f: F,
3182    ) -> SignalHandlerId {
3183        unsafe extern "C" fn notify_input_purpose_trampoline<P, F: Fn(&P) + 'static>(
3184            this: *mut gtk_sys::GtkEntry,
3185            _param_spec: glib_sys::gpointer,
3186            f: glib_sys::gpointer,
3187        ) where
3188            P: IsA<Entry>,
3189        {
3190            let f: &F = &*(f as *const F);
3191            f(&Entry::from_glib_borrow(this).unsafe_cast())
3192        }
3193        unsafe {
3194            let f: Box_<F> = Box_::new(f);
3195            connect_raw(
3196                self.as_ptr() as *mut _,
3197                b"notify::input-purpose\0".as_ptr() as *const _,
3198                Some(transmute(
3199                    notify_input_purpose_trampoline::<Self, F> as usize,
3200                )),
3201                Box_::into_raw(f),
3202            )
3203        }
3204    }
3205
3206    fn connect_property_invisible_char_notify<F: Fn(&Self) + 'static>(
3207        &self,
3208        f: F,
3209    ) -> SignalHandlerId {
3210        unsafe extern "C" fn notify_invisible_char_trampoline<P, F: Fn(&P) + 'static>(
3211            this: *mut gtk_sys::GtkEntry,
3212            _param_spec: glib_sys::gpointer,
3213            f: glib_sys::gpointer,
3214        ) where
3215            P: IsA<Entry>,
3216        {
3217            let f: &F = &*(f as *const F);
3218            f(&Entry::from_glib_borrow(this).unsafe_cast())
3219        }
3220        unsafe {
3221            let f: Box_<F> = Box_::new(f);
3222            connect_raw(
3223                self.as_ptr() as *mut _,
3224                b"notify::invisible-char\0".as_ptr() as *const _,
3225                Some(transmute(
3226                    notify_invisible_char_trampoline::<Self, F> as usize,
3227                )),
3228                Box_::into_raw(f),
3229            )
3230        }
3231    }
3232
3233    fn connect_property_invisible_char_set_notify<F: Fn(&Self) + 'static>(
3234        &self,
3235        f: F,
3236    ) -> SignalHandlerId {
3237        unsafe extern "C" fn notify_invisible_char_set_trampoline<P, F: Fn(&P) + 'static>(
3238            this: *mut gtk_sys::GtkEntry,
3239            _param_spec: glib_sys::gpointer,
3240            f: glib_sys::gpointer,
3241        ) where
3242            P: IsA<Entry>,
3243        {
3244            let f: &F = &*(f as *const F);
3245            f(&Entry::from_glib_borrow(this).unsafe_cast())
3246        }
3247        unsafe {
3248            let f: Box_<F> = Box_::new(f);
3249            connect_raw(
3250                self.as_ptr() as *mut _,
3251                b"notify::invisible-char-set\0".as_ptr() as *const _,
3252                Some(transmute(
3253                    notify_invisible_char_set_trampoline::<Self, F> as usize,
3254                )),
3255                Box_::into_raw(f),
3256            )
3257        }
3258    }
3259
3260    fn connect_property_max_length_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3261        unsafe extern "C" fn notify_max_length_trampoline<P, F: Fn(&P) + 'static>(
3262            this: *mut gtk_sys::GtkEntry,
3263            _param_spec: glib_sys::gpointer,
3264            f: glib_sys::gpointer,
3265        ) where
3266            P: IsA<Entry>,
3267        {
3268            let f: &F = &*(f as *const F);
3269            f(&Entry::from_glib_borrow(this).unsafe_cast())
3270        }
3271        unsafe {
3272            let f: Box_<F> = Box_::new(f);
3273            connect_raw(
3274                self.as_ptr() as *mut _,
3275                b"notify::max-length\0".as_ptr() as *const _,
3276                Some(transmute(notify_max_length_trampoline::<Self, F> as usize)),
3277                Box_::into_raw(f),
3278            )
3279        }
3280    }
3281
3282    fn connect_property_max_width_chars_notify<F: Fn(&Self) + 'static>(
3283        &self,
3284        f: F,
3285    ) -> SignalHandlerId {
3286        unsafe extern "C" fn notify_max_width_chars_trampoline<P, F: Fn(&P) + 'static>(
3287            this: *mut gtk_sys::GtkEntry,
3288            _param_spec: glib_sys::gpointer,
3289            f: glib_sys::gpointer,
3290        ) where
3291            P: IsA<Entry>,
3292        {
3293            let f: &F = &*(f as *const F);
3294            f(&Entry::from_glib_borrow(this).unsafe_cast())
3295        }
3296        unsafe {
3297            let f: Box_<F> = Box_::new(f);
3298            connect_raw(
3299                self.as_ptr() as *mut _,
3300                b"notify::max-width-chars\0".as_ptr() as *const _,
3301                Some(transmute(
3302                    notify_max_width_chars_trampoline::<Self, F> as usize,
3303                )),
3304                Box_::into_raw(f),
3305            )
3306        }
3307    }
3308
3309    fn connect_property_overwrite_mode_notify<F: Fn(&Self) + 'static>(
3310        &self,
3311        f: F,
3312    ) -> SignalHandlerId {
3313        unsafe extern "C" fn notify_overwrite_mode_trampoline<P, F: Fn(&P) + 'static>(
3314            this: *mut gtk_sys::GtkEntry,
3315            _param_spec: glib_sys::gpointer,
3316            f: glib_sys::gpointer,
3317        ) where
3318            P: IsA<Entry>,
3319        {
3320            let f: &F = &*(f as *const F);
3321            f(&Entry::from_glib_borrow(this).unsafe_cast())
3322        }
3323        unsafe {
3324            let f: Box_<F> = Box_::new(f);
3325            connect_raw(
3326                self.as_ptr() as *mut _,
3327                b"notify::overwrite-mode\0".as_ptr() as *const _,
3328                Some(transmute(
3329                    notify_overwrite_mode_trampoline::<Self, F> as usize,
3330                )),
3331                Box_::into_raw(f),
3332            )
3333        }
3334    }
3335
3336    fn connect_property_placeholder_text_notify<F: Fn(&Self) + 'static>(
3337        &self,
3338        f: F,
3339    ) -> SignalHandlerId {
3340        unsafe extern "C" fn notify_placeholder_text_trampoline<P, F: Fn(&P) + 'static>(
3341            this: *mut gtk_sys::GtkEntry,
3342            _param_spec: glib_sys::gpointer,
3343            f: glib_sys::gpointer,
3344        ) where
3345            P: IsA<Entry>,
3346        {
3347            let f: &F = &*(f as *const F);
3348            f(&Entry::from_glib_borrow(this).unsafe_cast())
3349        }
3350        unsafe {
3351            let f: Box_<F> = Box_::new(f);
3352            connect_raw(
3353                self.as_ptr() as *mut _,
3354                b"notify::placeholder-text\0".as_ptr() as *const _,
3355                Some(transmute(
3356                    notify_placeholder_text_trampoline::<Self, F> as usize,
3357                )),
3358                Box_::into_raw(f),
3359            )
3360        }
3361    }
3362
3363    fn connect_property_populate_all_notify<F: Fn(&Self) + 'static>(
3364        &self,
3365        f: F,
3366    ) -> SignalHandlerId {
3367        unsafe extern "C" fn notify_populate_all_trampoline<P, F: Fn(&P) + 'static>(
3368            this: *mut gtk_sys::GtkEntry,
3369            _param_spec: glib_sys::gpointer,
3370            f: glib_sys::gpointer,
3371        ) where
3372            P: IsA<Entry>,
3373        {
3374            let f: &F = &*(f as *const F);
3375            f(&Entry::from_glib_borrow(this).unsafe_cast())
3376        }
3377        unsafe {
3378            let f: Box_<F> = Box_::new(f);
3379            connect_raw(
3380                self.as_ptr() as *mut _,
3381                b"notify::populate-all\0".as_ptr() as *const _,
3382                Some(transmute(
3383                    notify_populate_all_trampoline::<Self, F> as usize,
3384                )),
3385                Box_::into_raw(f),
3386            )
3387        }
3388    }
3389
3390    fn connect_property_primary_icon_activatable_notify<F: Fn(&Self) + 'static>(
3391        &self,
3392        f: F,
3393    ) -> SignalHandlerId {
3394        unsafe extern "C" fn notify_primary_icon_activatable_trampoline<P, F: Fn(&P) + 'static>(
3395            this: *mut gtk_sys::GtkEntry,
3396            _param_spec: glib_sys::gpointer,
3397            f: glib_sys::gpointer,
3398        ) where
3399            P: IsA<Entry>,
3400        {
3401            let f: &F = &*(f as *const F);
3402            f(&Entry::from_glib_borrow(this).unsafe_cast())
3403        }
3404        unsafe {
3405            let f: Box_<F> = Box_::new(f);
3406            connect_raw(
3407                self.as_ptr() as *mut _,
3408                b"notify::primary-icon-activatable\0".as_ptr() as *const _,
3409                Some(transmute(
3410                    notify_primary_icon_activatable_trampoline::<Self, F> as usize,
3411                )),
3412                Box_::into_raw(f),
3413            )
3414        }
3415    }
3416
3417    fn connect_property_primary_icon_gicon_notify<F: Fn(&Self) + 'static>(
3418        &self,
3419        f: F,
3420    ) -> SignalHandlerId {
3421        unsafe extern "C" fn notify_primary_icon_gicon_trampoline<P, F: Fn(&P) + 'static>(
3422            this: *mut gtk_sys::GtkEntry,
3423            _param_spec: glib_sys::gpointer,
3424            f: glib_sys::gpointer,
3425        ) where
3426            P: IsA<Entry>,
3427        {
3428            let f: &F = &*(f as *const F);
3429            f(&Entry::from_glib_borrow(this).unsafe_cast())
3430        }
3431        unsafe {
3432            let f: Box_<F> = Box_::new(f);
3433            connect_raw(
3434                self.as_ptr() as *mut _,
3435                b"notify::primary-icon-gicon\0".as_ptr() as *const _,
3436                Some(transmute(
3437                    notify_primary_icon_gicon_trampoline::<Self, F> as usize,
3438                )),
3439                Box_::into_raw(f),
3440            )
3441        }
3442    }
3443
3444    fn connect_property_primary_icon_name_notify<F: Fn(&Self) + 'static>(
3445        &self,
3446        f: F,
3447    ) -> SignalHandlerId {
3448        unsafe extern "C" fn notify_primary_icon_name_trampoline<P, F: Fn(&P) + 'static>(
3449            this: *mut gtk_sys::GtkEntry,
3450            _param_spec: glib_sys::gpointer,
3451            f: glib_sys::gpointer,
3452        ) where
3453            P: IsA<Entry>,
3454        {
3455            let f: &F = &*(f as *const F);
3456            f(&Entry::from_glib_borrow(this).unsafe_cast())
3457        }
3458        unsafe {
3459            let f: Box_<F> = Box_::new(f);
3460            connect_raw(
3461                self.as_ptr() as *mut _,
3462                b"notify::primary-icon-name\0".as_ptr() as *const _,
3463                Some(transmute(
3464                    notify_primary_icon_name_trampoline::<Self, F> as usize,
3465                )),
3466                Box_::into_raw(f),
3467            )
3468        }
3469    }
3470
3471    fn connect_property_primary_icon_pixbuf_notify<F: Fn(&Self) + 'static>(
3472        &self,
3473        f: F,
3474    ) -> SignalHandlerId {
3475        unsafe extern "C" fn notify_primary_icon_pixbuf_trampoline<P, F: Fn(&P) + 'static>(
3476            this: *mut gtk_sys::GtkEntry,
3477            _param_spec: glib_sys::gpointer,
3478            f: glib_sys::gpointer,
3479        ) where
3480            P: IsA<Entry>,
3481        {
3482            let f: &F = &*(f as *const F);
3483            f(&Entry::from_glib_borrow(this).unsafe_cast())
3484        }
3485        unsafe {
3486            let f: Box_<F> = Box_::new(f);
3487            connect_raw(
3488                self.as_ptr() as *mut _,
3489                b"notify::primary-icon-pixbuf\0".as_ptr() as *const _,
3490                Some(transmute(
3491                    notify_primary_icon_pixbuf_trampoline::<Self, F> as usize,
3492                )),
3493                Box_::into_raw(f),
3494            )
3495        }
3496    }
3497
3498    fn connect_property_primary_icon_sensitive_notify<F: Fn(&Self) + 'static>(
3499        &self,
3500        f: F,
3501    ) -> SignalHandlerId {
3502        unsafe extern "C" fn notify_primary_icon_sensitive_trampoline<P, F: Fn(&P) + 'static>(
3503            this: *mut gtk_sys::GtkEntry,
3504            _param_spec: glib_sys::gpointer,
3505            f: glib_sys::gpointer,
3506        ) where
3507            P: IsA<Entry>,
3508        {
3509            let f: &F = &*(f as *const F);
3510            f(&Entry::from_glib_borrow(this).unsafe_cast())
3511        }
3512        unsafe {
3513            let f: Box_<F> = Box_::new(f);
3514            connect_raw(
3515                self.as_ptr() as *mut _,
3516                b"notify::primary-icon-sensitive\0".as_ptr() as *const _,
3517                Some(transmute(
3518                    notify_primary_icon_sensitive_trampoline::<Self, F> as usize,
3519                )),
3520                Box_::into_raw(f),
3521            )
3522        }
3523    }
3524
3525    fn connect_property_primary_icon_storage_type_notify<F: Fn(&Self) + 'static>(
3526        &self,
3527        f: F,
3528    ) -> SignalHandlerId {
3529        unsafe extern "C" fn notify_primary_icon_storage_type_trampoline<P, F: Fn(&P) + 'static>(
3530            this: *mut gtk_sys::GtkEntry,
3531            _param_spec: glib_sys::gpointer,
3532            f: glib_sys::gpointer,
3533        ) where
3534            P: IsA<Entry>,
3535        {
3536            let f: &F = &*(f as *const F);
3537            f(&Entry::from_glib_borrow(this).unsafe_cast())
3538        }
3539        unsafe {
3540            let f: Box_<F> = Box_::new(f);
3541            connect_raw(
3542                self.as_ptr() as *mut _,
3543                b"notify::primary-icon-storage-type\0".as_ptr() as *const _,
3544                Some(transmute(
3545                    notify_primary_icon_storage_type_trampoline::<Self, F> as usize,
3546                )),
3547                Box_::into_raw(f),
3548            )
3549        }
3550    }
3551
3552    fn connect_property_primary_icon_tooltip_markup_notify<F: Fn(&Self) + 'static>(
3553        &self,
3554        f: F,
3555    ) -> SignalHandlerId {
3556        unsafe extern "C" fn notify_primary_icon_tooltip_markup_trampoline<P, F: Fn(&P) + 'static>(
3557            this: *mut gtk_sys::GtkEntry,
3558            _param_spec: glib_sys::gpointer,
3559            f: glib_sys::gpointer,
3560        ) where
3561            P: IsA<Entry>,
3562        {
3563            let f: &F = &*(f as *const F);
3564            f(&Entry::from_glib_borrow(this).unsafe_cast())
3565        }
3566        unsafe {
3567            let f: Box_<F> = Box_::new(f);
3568            connect_raw(
3569                self.as_ptr() as *mut _,
3570                b"notify::primary-icon-tooltip-markup\0".as_ptr() as *const _,
3571                Some(transmute(
3572                    notify_primary_icon_tooltip_markup_trampoline::<Self, F> as usize,
3573                )),
3574                Box_::into_raw(f),
3575            )
3576        }
3577    }
3578
3579    fn connect_property_primary_icon_tooltip_text_notify<F: Fn(&Self) + 'static>(
3580        &self,
3581        f: F,
3582    ) -> SignalHandlerId {
3583        unsafe extern "C" fn notify_primary_icon_tooltip_text_trampoline<P, F: Fn(&P) + 'static>(
3584            this: *mut gtk_sys::GtkEntry,
3585            _param_spec: glib_sys::gpointer,
3586            f: glib_sys::gpointer,
3587        ) where
3588            P: IsA<Entry>,
3589        {
3590            let f: &F = &*(f as *const F);
3591            f(&Entry::from_glib_borrow(this).unsafe_cast())
3592        }
3593        unsafe {
3594            let f: Box_<F> = Box_::new(f);
3595            connect_raw(
3596                self.as_ptr() as *mut _,
3597                b"notify::primary-icon-tooltip-text\0".as_ptr() as *const _,
3598                Some(transmute(
3599                    notify_primary_icon_tooltip_text_trampoline::<Self, F> as usize,
3600                )),
3601                Box_::into_raw(f),
3602            )
3603        }
3604    }
3605
3606    fn connect_property_progress_fraction_notify<F: Fn(&Self) + 'static>(
3607        &self,
3608        f: F,
3609    ) -> SignalHandlerId {
3610        unsafe extern "C" fn notify_progress_fraction_trampoline<P, F: Fn(&P) + 'static>(
3611            this: *mut gtk_sys::GtkEntry,
3612            _param_spec: glib_sys::gpointer,
3613            f: glib_sys::gpointer,
3614        ) where
3615            P: IsA<Entry>,
3616        {
3617            let f: &F = &*(f as *const F);
3618            f(&Entry::from_glib_borrow(this).unsafe_cast())
3619        }
3620        unsafe {
3621            let f: Box_<F> = Box_::new(f);
3622            connect_raw(
3623                self.as_ptr() as *mut _,
3624                b"notify::progress-fraction\0".as_ptr() as *const _,
3625                Some(transmute(
3626                    notify_progress_fraction_trampoline::<Self, F> as usize,
3627                )),
3628                Box_::into_raw(f),
3629            )
3630        }
3631    }
3632
3633    fn connect_property_progress_pulse_step_notify<F: Fn(&Self) + 'static>(
3634        &self,
3635        f: F,
3636    ) -> SignalHandlerId {
3637        unsafe extern "C" fn notify_progress_pulse_step_trampoline<P, F: Fn(&P) + 'static>(
3638            this: *mut gtk_sys::GtkEntry,
3639            _param_spec: glib_sys::gpointer,
3640            f: glib_sys::gpointer,
3641        ) where
3642            P: IsA<Entry>,
3643        {
3644            let f: &F = &*(f as *const F);
3645            f(&Entry::from_glib_borrow(this).unsafe_cast())
3646        }
3647        unsafe {
3648            let f: Box_<F> = Box_::new(f);
3649            connect_raw(
3650                self.as_ptr() as *mut _,
3651                b"notify::progress-pulse-step\0".as_ptr() as *const _,
3652                Some(transmute(
3653                    notify_progress_pulse_step_trampoline::<Self, F> as usize,
3654                )),
3655                Box_::into_raw(f),
3656            )
3657        }
3658    }
3659
3660    fn connect_property_scroll_offset_notify<F: Fn(&Self) + 'static>(
3661        &self,
3662        f: F,
3663    ) -> SignalHandlerId {
3664        unsafe extern "C" fn notify_scroll_offset_trampoline<P, F: Fn(&P) + 'static>(
3665            this: *mut gtk_sys::GtkEntry,
3666            _param_spec: glib_sys::gpointer,
3667            f: glib_sys::gpointer,
3668        ) where
3669            P: IsA<Entry>,
3670        {
3671            let f: &F = &*(f as *const F);
3672            f(&Entry::from_glib_borrow(this).unsafe_cast())
3673        }
3674        unsafe {
3675            let f: Box_<F> = Box_::new(f);
3676            connect_raw(
3677                self.as_ptr() as *mut _,
3678                b"notify::scroll-offset\0".as_ptr() as *const _,
3679                Some(transmute(
3680                    notify_scroll_offset_trampoline::<Self, F> as usize,
3681                )),
3682                Box_::into_raw(f),
3683            )
3684        }
3685    }
3686
3687    fn connect_property_secondary_icon_activatable_notify<F: Fn(&Self) + 'static>(
3688        &self,
3689        f: F,
3690    ) -> SignalHandlerId {
3691        unsafe extern "C" fn notify_secondary_icon_activatable_trampoline<P, F: Fn(&P) + 'static>(
3692            this: *mut gtk_sys::GtkEntry,
3693            _param_spec: glib_sys::gpointer,
3694            f: glib_sys::gpointer,
3695        ) where
3696            P: IsA<Entry>,
3697        {
3698            let f: &F = &*(f as *const F);
3699            f(&Entry::from_glib_borrow(this).unsafe_cast())
3700        }
3701        unsafe {
3702            let f: Box_<F> = Box_::new(f);
3703            connect_raw(
3704                self.as_ptr() as *mut _,
3705                b"notify::secondary-icon-activatable\0".as_ptr() as *const _,
3706                Some(transmute(
3707                    notify_secondary_icon_activatable_trampoline::<Self, F> as usize,
3708                )),
3709                Box_::into_raw(f),
3710            )
3711        }
3712    }
3713
3714    fn connect_property_secondary_icon_gicon_notify<F: Fn(&Self) + 'static>(
3715        &self,
3716        f: F,
3717    ) -> SignalHandlerId {
3718        unsafe extern "C" fn notify_secondary_icon_gicon_trampoline<P, F: Fn(&P) + 'static>(
3719            this: *mut gtk_sys::GtkEntry,
3720            _param_spec: glib_sys::gpointer,
3721            f: glib_sys::gpointer,
3722        ) where
3723            P: IsA<Entry>,
3724        {
3725            let f: &F = &*(f as *const F);
3726            f(&Entry::from_glib_borrow(this).unsafe_cast())
3727        }
3728        unsafe {
3729            let f: Box_<F> = Box_::new(f);
3730            connect_raw(
3731                self.as_ptr() as *mut _,
3732                b"notify::secondary-icon-gicon\0".as_ptr() as *const _,
3733                Some(transmute(
3734                    notify_secondary_icon_gicon_trampoline::<Self, F> as usize,
3735                )),
3736                Box_::into_raw(f),
3737            )
3738        }
3739    }
3740
3741    fn connect_property_secondary_icon_name_notify<F: Fn(&Self) + 'static>(
3742        &self,
3743        f: F,
3744    ) -> SignalHandlerId {
3745        unsafe extern "C" fn notify_secondary_icon_name_trampoline<P, F: Fn(&P) + 'static>(
3746            this: *mut gtk_sys::GtkEntry,
3747            _param_spec: glib_sys::gpointer,
3748            f: glib_sys::gpointer,
3749        ) where
3750            P: IsA<Entry>,
3751        {
3752            let f: &F = &*(f as *const F);
3753            f(&Entry::from_glib_borrow(this).unsafe_cast())
3754        }
3755        unsafe {
3756            let f: Box_<F> = Box_::new(f);
3757            connect_raw(
3758                self.as_ptr() as *mut _,
3759                b"notify::secondary-icon-name\0".as_ptr() as *const _,
3760                Some(transmute(
3761                    notify_secondary_icon_name_trampoline::<Self, F> as usize,
3762                )),
3763                Box_::into_raw(f),
3764            )
3765        }
3766    }
3767
3768    fn connect_property_secondary_icon_pixbuf_notify<F: Fn(&Self) + 'static>(
3769        &self,
3770        f: F,
3771    ) -> SignalHandlerId {
3772        unsafe extern "C" fn notify_secondary_icon_pixbuf_trampoline<P, F: Fn(&P) + 'static>(
3773            this: *mut gtk_sys::GtkEntry,
3774            _param_spec: glib_sys::gpointer,
3775            f: glib_sys::gpointer,
3776        ) where
3777            P: IsA<Entry>,
3778        {
3779            let f: &F = &*(f as *const F);
3780            f(&Entry::from_glib_borrow(this).unsafe_cast())
3781        }
3782        unsafe {
3783            let f: Box_<F> = Box_::new(f);
3784            connect_raw(
3785                self.as_ptr() as *mut _,
3786                b"notify::secondary-icon-pixbuf\0".as_ptr() as *const _,
3787                Some(transmute(
3788                    notify_secondary_icon_pixbuf_trampoline::<Self, F> as usize,
3789                )),
3790                Box_::into_raw(f),
3791            )
3792        }
3793    }
3794
3795    fn connect_property_secondary_icon_sensitive_notify<F: Fn(&Self) + 'static>(
3796        &self,
3797        f: F,
3798    ) -> SignalHandlerId {
3799        unsafe extern "C" fn notify_secondary_icon_sensitive_trampoline<P, F: Fn(&P) + 'static>(
3800            this: *mut gtk_sys::GtkEntry,
3801            _param_spec: glib_sys::gpointer,
3802            f: glib_sys::gpointer,
3803        ) where
3804            P: IsA<Entry>,
3805        {
3806            let f: &F = &*(f as *const F);
3807            f(&Entry::from_glib_borrow(this).unsafe_cast())
3808        }
3809        unsafe {
3810            let f: Box_<F> = Box_::new(f);
3811            connect_raw(
3812                self.as_ptr() as *mut _,
3813                b"notify::secondary-icon-sensitive\0".as_ptr() as *const _,
3814                Some(transmute(
3815                    notify_secondary_icon_sensitive_trampoline::<Self, F> as usize,
3816                )),
3817                Box_::into_raw(f),
3818            )
3819        }
3820    }
3821
3822    fn connect_property_secondary_icon_storage_type_notify<F: Fn(&Self) + 'static>(
3823        &self,
3824        f: F,
3825    ) -> SignalHandlerId {
3826        unsafe extern "C" fn notify_secondary_icon_storage_type_trampoline<P, F: Fn(&P) + 'static>(
3827            this: *mut gtk_sys::GtkEntry,
3828            _param_spec: glib_sys::gpointer,
3829            f: glib_sys::gpointer,
3830        ) where
3831            P: IsA<Entry>,
3832        {
3833            let f: &F = &*(f as *const F);
3834            f(&Entry::from_glib_borrow(this).unsafe_cast())
3835        }
3836        unsafe {
3837            let f: Box_<F> = Box_::new(f);
3838            connect_raw(
3839                self.as_ptr() as *mut _,
3840                b"notify::secondary-icon-storage-type\0".as_ptr() as *const _,
3841                Some(transmute(
3842                    notify_secondary_icon_storage_type_trampoline::<Self, F> as usize,
3843                )),
3844                Box_::into_raw(f),
3845            )
3846        }
3847    }
3848
3849    fn connect_property_secondary_icon_tooltip_markup_notify<F: Fn(&Self) + 'static>(
3850        &self,
3851        f: F,
3852    ) -> SignalHandlerId {
3853        unsafe extern "C" fn notify_secondary_icon_tooltip_markup_trampoline<
3854            P,
3855            F: Fn(&P) + 'static,
3856        >(
3857            this: *mut gtk_sys::GtkEntry,
3858            _param_spec: glib_sys::gpointer,
3859            f: glib_sys::gpointer,
3860        ) where
3861            P: IsA<Entry>,
3862        {
3863            let f: &F = &*(f as *const F);
3864            f(&Entry::from_glib_borrow(this).unsafe_cast())
3865        }
3866        unsafe {
3867            let f: Box_<F> = Box_::new(f);
3868            connect_raw(
3869                self.as_ptr() as *mut _,
3870                b"notify::secondary-icon-tooltip-markup\0".as_ptr() as *const _,
3871                Some(transmute(
3872                    notify_secondary_icon_tooltip_markup_trampoline::<Self, F> as usize,
3873                )),
3874                Box_::into_raw(f),
3875            )
3876        }
3877    }
3878
3879    fn connect_property_secondary_icon_tooltip_text_notify<F: Fn(&Self) + 'static>(
3880        &self,
3881        f: F,
3882    ) -> SignalHandlerId {
3883        unsafe extern "C" fn notify_secondary_icon_tooltip_text_trampoline<P, F: Fn(&P) + 'static>(
3884            this: *mut gtk_sys::GtkEntry,
3885            _param_spec: glib_sys::gpointer,
3886            f: glib_sys::gpointer,
3887        ) where
3888            P: IsA<Entry>,
3889        {
3890            let f: &F = &*(f as *const F);
3891            f(&Entry::from_glib_borrow(this).unsafe_cast())
3892        }
3893        unsafe {
3894            let f: Box_<F> = Box_::new(f);
3895            connect_raw(
3896                self.as_ptr() as *mut _,
3897                b"notify::secondary-icon-tooltip-text\0".as_ptr() as *const _,
3898                Some(transmute(
3899                    notify_secondary_icon_tooltip_text_trampoline::<Self, F> as usize,
3900                )),
3901                Box_::into_raw(f),
3902            )
3903        }
3904    }
3905
3906    fn connect_property_selection_bound_notify<F: Fn(&Self) + 'static>(
3907        &self,
3908        f: F,
3909    ) -> SignalHandlerId {
3910        unsafe extern "C" fn notify_selection_bound_trampoline<P, F: Fn(&P) + 'static>(
3911            this: *mut gtk_sys::GtkEntry,
3912            _param_spec: glib_sys::gpointer,
3913            f: glib_sys::gpointer,
3914        ) where
3915            P: IsA<Entry>,
3916        {
3917            let f: &F = &*(f as *const F);
3918            f(&Entry::from_glib_borrow(this).unsafe_cast())
3919        }
3920        unsafe {
3921            let f: Box_<F> = Box_::new(f);
3922            connect_raw(
3923                self.as_ptr() as *mut _,
3924                b"notify::selection-bound\0".as_ptr() as *const _,
3925                Some(transmute(
3926                    notify_selection_bound_trampoline::<Self, F> as usize,
3927                )),
3928                Box_::into_raw(f),
3929            )
3930        }
3931    }
3932
3933    fn connect_property_shadow_type_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3934        unsafe extern "C" fn notify_shadow_type_trampoline<P, F: Fn(&P) + 'static>(
3935            this: *mut gtk_sys::GtkEntry,
3936            _param_spec: glib_sys::gpointer,
3937            f: glib_sys::gpointer,
3938        ) where
3939            P: IsA<Entry>,
3940        {
3941            let f: &F = &*(f as *const F);
3942            f(&Entry::from_glib_borrow(this).unsafe_cast())
3943        }
3944        unsafe {
3945            let f: Box_<F> = Box_::new(f);
3946            connect_raw(
3947                self.as_ptr() as *mut _,
3948                b"notify::shadow-type\0".as_ptr() as *const _,
3949                Some(transmute(notify_shadow_type_trampoline::<Self, F> as usize)),
3950                Box_::into_raw(f),
3951            )
3952        }
3953    }
3954
3955    fn connect_property_show_emoji_icon_notify<F: Fn(&Self) + 'static>(
3956        &self,
3957        f: F,
3958    ) -> SignalHandlerId {
3959        unsafe extern "C" fn notify_show_emoji_icon_trampoline<P, F: Fn(&P) + 'static>(
3960            this: *mut gtk_sys::GtkEntry,
3961            _param_spec: glib_sys::gpointer,
3962            f: glib_sys::gpointer,
3963        ) where
3964            P: IsA<Entry>,
3965        {
3966            let f: &F = &*(f as *const F);
3967            f(&Entry::from_glib_borrow(this).unsafe_cast())
3968        }
3969        unsafe {
3970            let f: Box_<F> = Box_::new(f);
3971            connect_raw(
3972                self.as_ptr() as *mut _,
3973                b"notify::show-emoji-icon\0".as_ptr() as *const _,
3974                Some(transmute(
3975                    notify_show_emoji_icon_trampoline::<Self, F> as usize,
3976                )),
3977                Box_::into_raw(f),
3978            )
3979        }
3980    }
3981
3982    fn connect_property_text_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3983        unsafe extern "C" fn notify_text_trampoline<P, F: Fn(&P) + 'static>(
3984            this: *mut gtk_sys::GtkEntry,
3985            _param_spec: glib_sys::gpointer,
3986            f: glib_sys::gpointer,
3987        ) where
3988            P: IsA<Entry>,
3989        {
3990            let f: &F = &*(f as *const F);
3991            f(&Entry::from_glib_borrow(this).unsafe_cast())
3992        }
3993        unsafe {
3994            let f: Box_<F> = Box_::new(f);
3995            connect_raw(
3996                self.as_ptr() as *mut _,
3997                b"notify::text\0".as_ptr() as *const _,
3998                Some(transmute(notify_text_trampoline::<Self, F> as usize)),
3999                Box_::into_raw(f),
4000            )
4001        }
4002    }
4003
4004    fn connect_property_text_length_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
4005        unsafe extern "C" fn notify_text_length_trampoline<P, F: Fn(&P) + 'static>(
4006            this: *mut gtk_sys::GtkEntry,
4007            _param_spec: glib_sys::gpointer,
4008            f: glib_sys::gpointer,
4009        ) where
4010            P: IsA<Entry>,
4011        {
4012            let f: &F = &*(f as *const F);
4013            f(&Entry::from_glib_borrow(this).unsafe_cast())
4014        }
4015        unsafe {
4016            let f: Box_<F> = Box_::new(f);
4017            connect_raw(
4018                self.as_ptr() as *mut _,
4019                b"notify::text-length\0".as_ptr() as *const _,
4020                Some(transmute(notify_text_length_trampoline::<Self, F> as usize)),
4021                Box_::into_raw(f),
4022            )
4023        }
4024    }
4025
4026    fn connect_property_truncate_multiline_notify<F: Fn(&Self) + 'static>(
4027        &self,
4028        f: F,
4029    ) -> SignalHandlerId {
4030        unsafe extern "C" fn notify_truncate_multiline_trampoline<P, F: Fn(&P) + 'static>(
4031            this: *mut gtk_sys::GtkEntry,
4032            _param_spec: glib_sys::gpointer,
4033            f: glib_sys::gpointer,
4034        ) where
4035            P: IsA<Entry>,
4036        {
4037            let f: &F = &*(f as *const F);
4038            f(&Entry::from_glib_borrow(this).unsafe_cast())
4039        }
4040        unsafe {
4041            let f: Box_<F> = Box_::new(f);
4042            connect_raw(
4043                self.as_ptr() as *mut _,
4044                b"notify::truncate-multiline\0".as_ptr() as *const _,
4045                Some(transmute(
4046                    notify_truncate_multiline_trampoline::<Self, F> as usize,
4047                )),
4048                Box_::into_raw(f),
4049            )
4050        }
4051    }
4052
4053    fn connect_property_visibility_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
4054        unsafe extern "C" fn notify_visibility_trampoline<P, F: Fn(&P) + 'static>(
4055            this: *mut gtk_sys::GtkEntry,
4056            _param_spec: glib_sys::gpointer,
4057            f: glib_sys::gpointer,
4058        ) where
4059            P: IsA<Entry>,
4060        {
4061            let f: &F = &*(f as *const F);
4062            f(&Entry::from_glib_borrow(this).unsafe_cast())
4063        }
4064        unsafe {
4065            let f: Box_<F> = Box_::new(f);
4066            connect_raw(
4067                self.as_ptr() as *mut _,
4068                b"notify::visibility\0".as_ptr() as *const _,
4069                Some(transmute(notify_visibility_trampoline::<Self, F> as usize)),
4070                Box_::into_raw(f),
4071            )
4072        }
4073    }
4074
4075    fn connect_property_width_chars_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
4076        unsafe extern "C" fn notify_width_chars_trampoline<P, F: Fn(&P) + 'static>(
4077            this: *mut gtk_sys::GtkEntry,
4078            _param_spec: glib_sys::gpointer,
4079            f: glib_sys::gpointer,
4080        ) where
4081            P: IsA<Entry>,
4082        {
4083            let f: &F = &*(f as *const F);
4084            f(&Entry::from_glib_borrow(this).unsafe_cast())
4085        }
4086        unsafe {
4087            let f: Box_<F> = Box_::new(f);
4088            connect_raw(
4089                self.as_ptr() as *mut _,
4090                b"notify::width-chars\0".as_ptr() as *const _,
4091                Some(transmute(notify_width_chars_trampoline::<Self, F> as usize)),
4092                Box_::into_raw(f),
4093            )
4094        }
4095    }
4096
4097    fn connect_property_xalign_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
4098        unsafe extern "C" fn notify_xalign_trampoline<P, F: Fn(&P) + 'static>(
4099            this: *mut gtk_sys::GtkEntry,
4100            _param_spec: glib_sys::gpointer,
4101            f: glib_sys::gpointer,
4102        ) where
4103            P: IsA<Entry>,
4104        {
4105            let f: &F = &*(f as *const F);
4106            f(&Entry::from_glib_borrow(this).unsafe_cast())
4107        }
4108        unsafe {
4109            let f: Box_<F> = Box_::new(f);
4110            connect_raw(
4111                self.as_ptr() as *mut _,
4112                b"notify::xalign\0".as_ptr() as *const _,
4113                Some(transmute(notify_xalign_trampoline::<Self, F> as usize)),
4114                Box_::into_raw(f),
4115            )
4116        }
4117    }
4118}
4119
4120impl fmt::Display for Entry {
4121    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4122        write!(f, "Entry")
4123    }
4124}