1use 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 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}