gtk4/auto/cell_renderer_accel.rs
1// This file was generated by gir (https://github.com/gtk-rs/gir)
2// from gir-files (https://github.com/gtk-rs/gir-files)
3// DO NOT EDIT
4#![allow(deprecated)]
5
6use crate::{
7 ffi, CellRenderer, CellRendererAccelMode, CellRendererMode, CellRendererText, TreePath,
8};
9use glib::{
10 object::ObjectType as _,
11 prelude::*,
12 signal::{connect_raw, SignalHandlerId},
13 translate::*,
14};
15use std::boxed::Box as Box_;
16
17glib::wrapper! {
18 /// Applications editing keyboard accelerators should
19 /// provide their own implementation according to platform design
20 /// guidelines
21 /// Renders a keyboard accelerator in a cell
22 ///
23 /// [`CellRendererAccel`][crate::CellRendererAccel] displays a keyboard accelerator (i.e. a key
24 /// combination like `Control + a`). If the cell renderer is editable,
25 /// the accelerator can be changed by simply typing the new combination.
26 ///
27 /// ## Properties
28 ///
29 ///
30 /// #### `accel-key`
31 /// The keyval of the accelerator.
32 ///
33 /// Readable | Writeable
34 ///
35 ///
36 /// #### `accel-mode`
37 /// Determines if the edited accelerators are GTK accelerators. If
38 /// they are, consumed modifiers are suppressed, only accelerators
39 /// accepted by GTK are allowed, and the accelerators are rendered
40 /// in the same way as they are in menus.
41 ///
42 /// Readable | Writeable
43 ///
44 ///
45 /// #### `accel-mods`
46 /// The modifier mask of the accelerator.
47 ///
48 /// Readable | Writeable
49 ///
50 ///
51 /// #### `keycode`
52 /// The hardware keycode of the accelerator. Note that the hardware keycode is
53 /// only relevant if the key does not have a keyval. Normally, the keyboard
54 /// configuration should assign keyvals to all keys.
55 ///
56 /// Readable | Writeable
57 /// <details><summary><h4>CellRendererText</h4></summary>
58 ///
59 ///
60 /// #### `align-set`
61 /// Readable | Writeable
62 ///
63 ///
64 /// #### `alignment`
65 /// Specifies how to align the lines of text with respect to each other.
66 ///
67 /// Note that this property describes how to align the lines of text in
68 /// case there are several of them. The "xalign" property of [`CellRenderer`][crate::CellRenderer],
69 /// on the other hand, sets the horizontal alignment of the whole text.
70 ///
71 /// Readable | Writeable
72 ///
73 ///
74 /// #### `attributes`
75 /// Readable | Writeable
76 ///
77 ///
78 /// #### `background`
79 /// Writeable
80 ///
81 ///
82 /// #### `background-rgba`
83 /// Background color as a [`gdk::RGBA`][crate::gdk::RGBA]
84 ///
85 /// Readable | Writeable
86 ///
87 ///
88 /// #### `background-set`
89 /// Readable | Writeable
90 ///
91 ///
92 /// #### `editable`
93 /// Readable | Writeable
94 ///
95 ///
96 /// #### `editable-set`
97 /// Readable | Writeable
98 ///
99 ///
100 /// #### `ellipsize`
101 /// Specifies the preferred place to ellipsize the string, if the cell renderer
102 /// does not have enough room to display the entire string. Setting it to
103 /// [`pango::EllipsizeMode::None`][crate::pango::EllipsizeMode::None] turns off ellipsizing. See the wrap-width property
104 /// for another way of making the text fit into a given width.
105 ///
106 /// Readable | Writeable
107 ///
108 ///
109 /// #### `ellipsize-set`
110 /// Readable | Writeable
111 ///
112 ///
113 /// #### `family`
114 /// Readable | Writeable
115 ///
116 ///
117 /// #### `family-set`
118 /// Readable | Writeable
119 ///
120 ///
121 /// #### `font`
122 /// Readable | Writeable
123 ///
124 ///
125 /// #### `font-desc`
126 /// Readable | Writeable
127 ///
128 ///
129 /// #### `foreground`
130 /// Writeable
131 ///
132 ///
133 /// #### `foreground-rgba`
134 /// Foreground color as a [`gdk::RGBA`][crate::gdk::RGBA]
135 ///
136 /// Readable | Writeable
137 ///
138 ///
139 /// #### `foreground-set`
140 /// Readable | Writeable
141 ///
142 ///
143 /// #### `language`
144 /// Readable | Writeable
145 ///
146 ///
147 /// #### `language-set`
148 /// Readable | Writeable
149 ///
150 ///
151 /// #### `markup`
152 /// Writeable
153 ///
154 ///
155 /// #### `max-width-chars`
156 /// The desired maximum width of the cell, in characters. If this property
157 /// is set to -1, the width will be calculated automatically.
158 ///
159 /// For cell renderers that ellipsize or wrap text; this property
160 /// controls the maximum reported width of the cell. The
161 /// cell should not receive any greater allocation unless it is
162 /// set to expand in its [`CellLayout`][crate::CellLayout] and all of the cell's siblings
163 /// have received their natural width.
164 ///
165 /// Readable | Writeable
166 ///
167 ///
168 /// #### `placeholder-text`
169 /// The text that will be displayed in the [`CellRenderer`][crate::CellRenderer] if
170 /// `GtkCellRendererText:editable` is [`true`] and the cell is empty.
171 ///
172 /// Readable | Writeable
173 ///
174 ///
175 /// #### `rise`
176 /// Readable | Writeable
177 ///
178 ///
179 /// #### `rise-set`
180 /// Readable | Writeable
181 ///
182 ///
183 /// #### `scale`
184 /// Readable | Writeable
185 ///
186 ///
187 /// #### `scale-set`
188 /// Readable | Writeable
189 ///
190 ///
191 /// #### `single-paragraph-mode`
192 /// Readable | Writeable
193 ///
194 ///
195 /// #### `size`
196 /// Readable | Writeable
197 ///
198 ///
199 /// #### `size-points`
200 /// Readable | Writeable
201 ///
202 ///
203 /// #### `size-set`
204 /// Readable | Writeable
205 ///
206 ///
207 /// #### `stretch`
208 /// Readable | Writeable
209 ///
210 ///
211 /// #### `stretch-set`
212 /// Readable | Writeable
213 ///
214 ///
215 /// #### `strikethrough`
216 /// Readable | Writeable
217 ///
218 ///
219 /// #### `strikethrough-set`
220 /// Readable | Writeable
221 ///
222 ///
223 /// #### `style`
224 /// Readable | Writeable
225 ///
226 ///
227 /// #### `style-set`
228 /// Readable | Writeable
229 ///
230 ///
231 /// #### `text`
232 /// Readable | Writeable
233 ///
234 ///
235 /// #### `underline`
236 /// Readable | Writeable
237 ///
238 ///
239 /// #### `underline-set`
240 /// Readable | Writeable
241 ///
242 ///
243 /// #### `variant`
244 /// Readable | Writeable
245 ///
246 ///
247 /// #### `variant-set`
248 /// Readable | Writeable
249 ///
250 ///
251 /// #### `weight`
252 /// Readable | Writeable
253 ///
254 ///
255 /// #### `weight-set`
256 /// Readable | Writeable
257 ///
258 ///
259 /// #### `width-chars`
260 /// The desired width of the cell, in characters. If this property is set to
261 /// -1, the width will be calculated automatically, otherwise the cell will
262 /// request either 3 characters or the property value, whichever is greater.
263 ///
264 /// Readable | Writeable
265 ///
266 ///
267 /// #### `wrap-mode`
268 /// Specifies how to break the string into multiple lines, if the cell
269 /// renderer does not have enough room to display the entire string.
270 /// This property has no effect unless the wrap-width property is set.
271 ///
272 /// Readable | Writeable
273 ///
274 ///
275 /// #### `wrap-width`
276 /// Specifies the minimum width at which the text is wrapped. The wrap-mode property can
277 /// be used to influence at what character positions the line breaks can be placed.
278 /// Setting wrap-width to -1 turns wrapping off.
279 ///
280 /// Readable | Writeable
281 /// </details>
282 /// <details><summary><h4>CellRenderer</h4></summary>
283 ///
284 ///
285 /// #### `cell-background`
286 /// Writeable
287 ///
288 ///
289 /// #### `cell-background-rgba`
290 /// Cell background as a [`gdk::RGBA`][crate::gdk::RGBA]
291 ///
292 /// Readable | Writeable
293 ///
294 ///
295 /// #### `cell-background-set`
296 /// Readable | Writeable
297 ///
298 ///
299 /// #### `editing`
300 /// Readable
301 ///
302 ///
303 /// #### `height`
304 /// Readable | Writeable
305 ///
306 ///
307 /// #### `is-expanded`
308 /// Readable | Writeable
309 ///
310 ///
311 /// #### `is-expander`
312 /// Readable | Writeable
313 ///
314 ///
315 /// #### `mode`
316 /// Readable | Writeable
317 ///
318 ///
319 /// #### `sensitive`
320 /// Readable | Writeable
321 ///
322 ///
323 /// #### `visible`
324 /// Readable | Writeable
325 ///
326 ///
327 /// #### `width`
328 /// Readable | Writeable
329 ///
330 ///
331 /// #### `xalign`
332 /// Readable | Writeable
333 ///
334 ///
335 /// #### `xpad`
336 /// Readable | Writeable
337 ///
338 ///
339 /// #### `yalign`
340 /// Readable | Writeable
341 ///
342 ///
343 /// #### `ypad`
344 /// Readable | Writeable
345 /// </details>
346 ///
347 /// ## Signals
348 ///
349 ///
350 /// #### `accel-cleared`
351 /// Gets emitted when the user has removed the accelerator.
352 ///
353 ///
354 ///
355 ///
356 /// #### `accel-edited`
357 /// Gets emitted when the user has selected a new accelerator.
358 ///
359 ///
360 /// <details><summary><h4>CellRendererText</h4></summary>
361 ///
362 ///
363 /// #### `edited`
364 /// This signal is emitted after @renderer has been edited.
365 ///
366 /// It is the responsibility of the application to update the model
367 /// and store @new_text at the position indicated by @path.
368 ///
369 ///
370 /// </details>
371 /// <details><summary><h4>CellRenderer</h4></summary>
372 ///
373 ///
374 /// #### `editing-canceled`
375 /// This signal gets emitted when the user cancels the process of editing a
376 /// cell. For example, an editable cell renderer could be written to cancel
377 /// editing when the user presses Escape.
378 ///
379 /// See also: gtk_cell_renderer_stop_editing().
380 ///
381 ///
382 ///
383 ///
384 /// #### `editing-started`
385 /// This signal gets emitted when a cell starts to be edited.
386 /// The intended use of this signal is to do special setup
387 /// on @editable, e.g. adding a [`EntryCompletion`][crate::EntryCompletion] or setting
388 /// up additional columns in a [`ComboBox`][crate::ComboBox].
389 ///
390 /// See gtk_cell_editable_start_editing() for information on the lifecycle of
391 /// the @editable and a way to do setup that doesn’t depend on the @renderer.
392 ///
393 /// Note that GTK doesn't guarantee that cell renderers will
394 /// continue to use the same kind of widget for editing in future
395 /// releases, therefore you should check the type of @editable
396 /// before doing any specific setup, as in the following example:
397 ///
398 ///
399 /// **⚠️ The following code is in C ⚠️**
400 ///
401 /// ```C
402 /// static void
403 /// text_editing_started (GtkCellRenderer *cell,
404 /// GtkCellEditable *editable,
405 /// const char *path,
406 /// gpointer data)
407 /// {
408 /// if (GTK_IS_ENTRY (editable))
409 /// {
410 /// GtkEntry *entry = GTK_ENTRY (editable);
411 ///
412 /// // ... create a GtkEntryCompletion
413 ///
414 /// gtk_entry_set_completion (entry, completion);
415 /// }
416 /// }
417 /// ```
418 ///
419 ///
420 /// </details>
421 ///
422 /// # Implements
423 ///
424 /// [`CellRendererTextExt`][trait@crate::prelude::CellRendererTextExt], [`CellRendererExt`][trait@crate::prelude::CellRendererExt], [`trait@glib::ObjectExt`], [`CellRendererExtManual`][trait@crate::prelude::CellRendererExtManual]
425 #[doc(alias = "GtkCellRendererAccel")]
426 pub struct CellRendererAccel(Object<ffi::GtkCellRendererAccel>) @extends CellRendererText, CellRenderer;
427
428 match fn {
429 type_ => || ffi::gtk_cell_renderer_accel_get_type(),
430 }
431}
432
433impl CellRendererAccel {
434 /// Creates a new [`CellRendererAccel`][crate::CellRendererAccel].
435 ///
436 /// # Deprecated since 4.10
437 ///
438 ///
439 /// # Returns
440 ///
441 /// the new cell renderer
442 #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
443 #[allow(deprecated)]
444 #[doc(alias = "gtk_cell_renderer_accel_new")]
445 pub fn new() -> CellRendererAccel {
446 assert_initialized_main_thread!();
447 unsafe { CellRenderer::from_glib_none(ffi::gtk_cell_renderer_accel_new()).unsafe_cast() }
448 }
449
450 // rustdoc-stripper-ignore-next
451 /// Creates a new builder-pattern struct instance to construct [`CellRendererAccel`] objects.
452 ///
453 /// This method returns an instance of [`CellRendererAccelBuilder`](crate::builders::CellRendererAccelBuilder) which can be used to create [`CellRendererAccel`] objects.
454 pub fn builder() -> CellRendererAccelBuilder {
455 CellRendererAccelBuilder::new()
456 }
457
458 /// The keyval of the accelerator.
459 #[doc(alias = "accel-key")]
460 pub fn accel_key(&self) -> u32 {
461 ObjectExt::property(self, "accel-key")
462 }
463
464 /// The keyval of the accelerator.
465 #[doc(alias = "accel-key")]
466 pub fn set_accel_key(&self, accel_key: u32) {
467 ObjectExt::set_property(self, "accel-key", accel_key)
468 }
469
470 /// Determines if the edited accelerators are GTK accelerators. If
471 /// they are, consumed modifiers are suppressed, only accelerators
472 /// accepted by GTK are allowed, and the accelerators are rendered
473 /// in the same way as they are in menus.
474 #[doc(alias = "accel-mode")]
475 pub fn accel_mode(&self) -> CellRendererAccelMode {
476 ObjectExt::property(self, "accel-mode")
477 }
478
479 /// Determines if the edited accelerators are GTK accelerators. If
480 /// they are, consumed modifiers are suppressed, only accelerators
481 /// accepted by GTK are allowed, and the accelerators are rendered
482 /// in the same way as they are in menus.
483 #[doc(alias = "accel-mode")]
484 pub fn set_accel_mode(&self, accel_mode: CellRendererAccelMode) {
485 ObjectExt::set_property(self, "accel-mode", accel_mode)
486 }
487
488 /// The modifier mask of the accelerator.
489 #[doc(alias = "accel-mods")]
490 pub fn accel_mods(&self) -> gdk::ModifierType {
491 ObjectExt::property(self, "accel-mods")
492 }
493
494 /// The modifier mask of the accelerator.
495 #[doc(alias = "accel-mods")]
496 pub fn set_accel_mods(&self, accel_mods: gdk::ModifierType) {
497 ObjectExt::set_property(self, "accel-mods", accel_mods)
498 }
499
500 /// The hardware keycode of the accelerator. Note that the hardware keycode is
501 /// only relevant if the key does not have a keyval. Normally, the keyboard
502 /// configuration should assign keyvals to all keys.
503 pub fn keycode(&self) -> u32 {
504 ObjectExt::property(self, "keycode")
505 }
506
507 /// The hardware keycode of the accelerator. Note that the hardware keycode is
508 /// only relevant if the key does not have a keyval. Normally, the keyboard
509 /// configuration should assign keyvals to all keys.
510 pub fn set_keycode(&self, keycode: u32) {
511 ObjectExt::set_property(self, "keycode", keycode)
512 }
513
514 /// Gets emitted when the user has removed the accelerator.
515 /// ## `path_string`
516 /// the path identifying the row of the edited cell
517 #[doc(alias = "accel-cleared")]
518 pub fn connect_accel_cleared<F: Fn(&Self, TreePath) + 'static>(&self, f: F) -> SignalHandlerId {
519 unsafe extern "C" fn accel_cleared_trampoline<
520 F: Fn(&CellRendererAccel, TreePath) + 'static,
521 >(
522 this: *mut ffi::GtkCellRendererAccel,
523 path_string: *mut std::ffi::c_char,
524 f: glib::ffi::gpointer,
525 ) {
526 let f: &F = &*(f as *const F);
527 let path = from_glib_full(crate::ffi::gtk_tree_path_new_from_string(path_string));
528 f(&from_glib_borrow(this), path)
529 }
530 unsafe {
531 let f: Box_<F> = Box_::new(f);
532 connect_raw(
533 self.as_ptr() as *mut _,
534 c"accel-cleared".as_ptr() as *const _,
535 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
536 accel_cleared_trampoline::<F> as *const (),
537 )),
538 Box_::into_raw(f),
539 )
540 }
541 }
542
543 /// Gets emitted when the user has selected a new accelerator.
544 /// ## `path_string`
545 /// the path identifying the row of the edited cell
546 /// ## `accel_key`
547 /// the new accelerator keyval
548 /// ## `accel_mods`
549 /// the new accelerator modifier mask
550 /// ## `hardware_keycode`
551 /// the keycode of the new accelerator
552 #[doc(alias = "accel-edited")]
553 pub fn connect_accel_edited<F: Fn(&Self, TreePath, u32, gdk::ModifierType, u32) + 'static>(
554 &self,
555 f: F,
556 ) -> SignalHandlerId {
557 unsafe extern "C" fn accel_edited_trampoline<
558 F: Fn(&CellRendererAccel, TreePath, u32, gdk::ModifierType, u32) + 'static,
559 >(
560 this: *mut ffi::GtkCellRendererAccel,
561 path_string: *mut std::ffi::c_char,
562 accel_key: std::ffi::c_uint,
563 accel_mods: gdk::ffi::GdkModifierType,
564 hardware_keycode: std::ffi::c_uint,
565 f: glib::ffi::gpointer,
566 ) {
567 let f: &F = &*(f as *const F);
568 let path = from_glib_full(crate::ffi::gtk_tree_path_new_from_string(path_string));
569 f(
570 &from_glib_borrow(this),
571 path,
572 accel_key,
573 from_glib(accel_mods),
574 hardware_keycode,
575 )
576 }
577 unsafe {
578 let f: Box_<F> = Box_::new(f);
579 connect_raw(
580 self.as_ptr() as *mut _,
581 c"accel-edited".as_ptr() as *const _,
582 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
583 accel_edited_trampoline::<F> as *const (),
584 )),
585 Box_::into_raw(f),
586 )
587 }
588 }
589
590 #[doc(alias = "accel-key")]
591 pub fn connect_accel_key_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
592 unsafe extern "C" fn notify_accel_key_trampoline<F: Fn(&CellRendererAccel) + 'static>(
593 this: *mut ffi::GtkCellRendererAccel,
594 _param_spec: glib::ffi::gpointer,
595 f: glib::ffi::gpointer,
596 ) {
597 let f: &F = &*(f as *const F);
598 f(&from_glib_borrow(this))
599 }
600 unsafe {
601 let f: Box_<F> = Box_::new(f);
602 connect_raw(
603 self.as_ptr() as *mut _,
604 c"notify::accel-key".as_ptr() as *const _,
605 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
606 notify_accel_key_trampoline::<F> as *const (),
607 )),
608 Box_::into_raw(f),
609 )
610 }
611 }
612
613 #[doc(alias = "accel-mode")]
614 pub fn connect_accel_mode_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
615 unsafe extern "C" fn notify_accel_mode_trampoline<F: Fn(&CellRendererAccel) + 'static>(
616 this: *mut ffi::GtkCellRendererAccel,
617 _param_spec: glib::ffi::gpointer,
618 f: glib::ffi::gpointer,
619 ) {
620 let f: &F = &*(f as *const F);
621 f(&from_glib_borrow(this))
622 }
623 unsafe {
624 let f: Box_<F> = Box_::new(f);
625 connect_raw(
626 self.as_ptr() as *mut _,
627 c"notify::accel-mode".as_ptr() as *const _,
628 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
629 notify_accel_mode_trampoline::<F> as *const (),
630 )),
631 Box_::into_raw(f),
632 )
633 }
634 }
635
636 #[doc(alias = "accel-mods")]
637 pub fn connect_accel_mods_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
638 unsafe extern "C" fn notify_accel_mods_trampoline<F: Fn(&CellRendererAccel) + 'static>(
639 this: *mut ffi::GtkCellRendererAccel,
640 _param_spec: glib::ffi::gpointer,
641 f: glib::ffi::gpointer,
642 ) {
643 let f: &F = &*(f as *const F);
644 f(&from_glib_borrow(this))
645 }
646 unsafe {
647 let f: Box_<F> = Box_::new(f);
648 connect_raw(
649 self.as_ptr() as *mut _,
650 c"notify::accel-mods".as_ptr() as *const _,
651 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
652 notify_accel_mods_trampoline::<F> as *const (),
653 )),
654 Box_::into_raw(f),
655 )
656 }
657 }
658
659 #[doc(alias = "keycode")]
660 pub fn connect_keycode_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
661 unsafe extern "C" fn notify_keycode_trampoline<F: Fn(&CellRendererAccel) + 'static>(
662 this: *mut ffi::GtkCellRendererAccel,
663 _param_spec: glib::ffi::gpointer,
664 f: glib::ffi::gpointer,
665 ) {
666 let f: &F = &*(f as *const F);
667 f(&from_glib_borrow(this))
668 }
669 unsafe {
670 let f: Box_<F> = Box_::new(f);
671 connect_raw(
672 self.as_ptr() as *mut _,
673 c"notify::keycode".as_ptr() as *const _,
674 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
675 notify_keycode_trampoline::<F> as *const (),
676 )),
677 Box_::into_raw(f),
678 )
679 }
680 }
681}
682
683impl Default for CellRendererAccel {
684 fn default() -> Self {
685 Self::new()
686 }
687}
688
689// rustdoc-stripper-ignore-next
690/// A [builder-pattern] type to construct [`CellRendererAccel`] objects.
691///
692/// [builder-pattern]: https://doc.rust-lang.org/1.0.0/style/ownership/builders.html
693#[must_use = "The builder must be built to be used"]
694pub struct CellRendererAccelBuilder {
695 builder: glib::object::ObjectBuilder<'static, CellRendererAccel>,
696}
697
698impl CellRendererAccelBuilder {
699 fn new() -> Self {
700 Self {
701 builder: glib::object::Object::builder(),
702 }
703 }
704
705 /// The keyval of the accelerator.
706 pub fn accel_key(self, accel_key: u32) -> Self {
707 Self {
708 builder: self.builder.property("accel-key", accel_key),
709 }
710 }
711
712 /// Determines if the edited accelerators are GTK accelerators. If
713 /// they are, consumed modifiers are suppressed, only accelerators
714 /// accepted by GTK are allowed, and the accelerators are rendered
715 /// in the same way as they are in menus.
716 pub fn accel_mode(self, accel_mode: CellRendererAccelMode) -> Self {
717 Self {
718 builder: self.builder.property("accel-mode", accel_mode),
719 }
720 }
721
722 /// The modifier mask of the accelerator.
723 pub fn accel_mods(self, accel_mods: gdk::ModifierType) -> Self {
724 Self {
725 builder: self.builder.property("accel-mods", accel_mods),
726 }
727 }
728
729 /// The hardware keycode of the accelerator. Note that the hardware keycode is
730 /// only relevant if the key does not have a keyval. Normally, the keyboard
731 /// configuration should assign keyvals to all keys.
732 pub fn keycode(self, keycode: u32) -> Self {
733 Self {
734 builder: self.builder.property("keycode", keycode),
735 }
736 }
737
738 pub fn align_set(self, align_set: bool) -> Self {
739 Self {
740 builder: self.builder.property("align-set", align_set),
741 }
742 }
743
744 /// Specifies how to align the lines of text with respect to each other.
745 ///
746 /// Note that this property describes how to align the lines of text in
747 /// case there are several of them. The "xalign" property of [`CellRenderer`][crate::CellRenderer],
748 /// on the other hand, sets the horizontal alignment of the whole text.
749 pub fn alignment(self, alignment: pango::Alignment) -> Self {
750 Self {
751 builder: self.builder.property("alignment", alignment),
752 }
753 }
754
755 pub fn attributes(self, attributes: &pango::AttrList) -> Self {
756 Self {
757 builder: self.builder.property("attributes", attributes.clone()),
758 }
759 }
760
761 pub fn background(self, background: impl Into<glib::GString>) -> Self {
762 Self {
763 builder: self.builder.property("background", background.into()),
764 }
765 }
766
767 /// Background color as a [`gdk::RGBA`][crate::gdk::RGBA]
768 pub fn background_rgba(self, background_rgba: &gdk::RGBA) -> Self {
769 Self {
770 builder: self.builder.property("background-rgba", background_rgba),
771 }
772 }
773
774 pub fn background_set(self, background_set: bool) -> Self {
775 Self {
776 builder: self.builder.property("background-set", background_set),
777 }
778 }
779
780 pub fn editable(self, editable: bool) -> Self {
781 Self {
782 builder: self.builder.property("editable", editable),
783 }
784 }
785
786 pub fn editable_set(self, editable_set: bool) -> Self {
787 Self {
788 builder: self.builder.property("editable-set", editable_set),
789 }
790 }
791
792 /// Specifies the preferred place to ellipsize the string, if the cell renderer
793 /// does not have enough room to display the entire string. Setting it to
794 /// [`pango::EllipsizeMode::None`][crate::pango::EllipsizeMode::None] turns off ellipsizing. See the wrap-width property
795 /// for another way of making the text fit into a given width.
796 pub fn ellipsize(self, ellipsize: pango::EllipsizeMode) -> Self {
797 Self {
798 builder: self.builder.property("ellipsize", ellipsize),
799 }
800 }
801
802 pub fn ellipsize_set(self, ellipsize_set: bool) -> Self {
803 Self {
804 builder: self.builder.property("ellipsize-set", ellipsize_set),
805 }
806 }
807
808 pub fn family(self, family: impl Into<glib::GString>) -> Self {
809 Self {
810 builder: self.builder.property("family", family.into()),
811 }
812 }
813
814 pub fn family_set(self, family_set: bool) -> Self {
815 Self {
816 builder: self.builder.property("family-set", family_set),
817 }
818 }
819
820 pub fn font(self, font: impl Into<glib::GString>) -> Self {
821 Self {
822 builder: self.builder.property("font", font.into()),
823 }
824 }
825
826 pub fn font_desc(self, font_desc: &pango::FontDescription) -> Self {
827 Self {
828 builder: self.builder.property("font-desc", font_desc),
829 }
830 }
831
832 pub fn foreground(self, foreground: impl Into<glib::GString>) -> Self {
833 Self {
834 builder: self.builder.property("foreground", foreground.into()),
835 }
836 }
837
838 /// Foreground color as a [`gdk::RGBA`][crate::gdk::RGBA]
839 pub fn foreground_rgba(self, foreground_rgba: &gdk::RGBA) -> Self {
840 Self {
841 builder: self.builder.property("foreground-rgba", foreground_rgba),
842 }
843 }
844
845 pub fn foreground_set(self, foreground_set: bool) -> Self {
846 Self {
847 builder: self.builder.property("foreground-set", foreground_set),
848 }
849 }
850
851 pub fn language(self, language: impl Into<glib::GString>) -> Self {
852 Self {
853 builder: self.builder.property("language", language.into()),
854 }
855 }
856
857 pub fn language_set(self, language_set: bool) -> Self {
858 Self {
859 builder: self.builder.property("language-set", language_set),
860 }
861 }
862
863 pub fn markup(self, markup: impl Into<glib::GString>) -> Self {
864 Self {
865 builder: self.builder.property("markup", markup.into()),
866 }
867 }
868
869 /// The desired maximum width of the cell, in characters. If this property
870 /// is set to -1, the width will be calculated automatically.
871 ///
872 /// For cell renderers that ellipsize or wrap text; this property
873 /// controls the maximum reported width of the cell. The
874 /// cell should not receive any greater allocation unless it is
875 /// set to expand in its [`CellLayout`][crate::CellLayout] and all of the cell's siblings
876 /// have received their natural width.
877 pub fn max_width_chars(self, max_width_chars: i32) -> Self {
878 Self {
879 builder: self.builder.property("max-width-chars", max_width_chars),
880 }
881 }
882
883 /// The text that will be displayed in the [`CellRenderer`][crate::CellRenderer] if
884 /// `GtkCellRendererText:editable` is [`true`] and the cell is empty.
885 pub fn placeholder_text(self, placeholder_text: impl Into<glib::GString>) -> Self {
886 Self {
887 builder: self
888 .builder
889 .property("placeholder-text", placeholder_text.into()),
890 }
891 }
892
893 pub fn rise(self, rise: i32) -> Self {
894 Self {
895 builder: self.builder.property("rise", rise),
896 }
897 }
898
899 pub fn rise_set(self, rise_set: bool) -> Self {
900 Self {
901 builder: self.builder.property("rise-set", rise_set),
902 }
903 }
904
905 pub fn scale(self, scale: f64) -> Self {
906 Self {
907 builder: self.builder.property("scale", scale),
908 }
909 }
910
911 pub fn scale_set(self, scale_set: bool) -> Self {
912 Self {
913 builder: self.builder.property("scale-set", scale_set),
914 }
915 }
916
917 pub fn single_paragraph_mode(self, single_paragraph_mode: bool) -> Self {
918 Self {
919 builder: self
920 .builder
921 .property("single-paragraph-mode", single_paragraph_mode),
922 }
923 }
924
925 pub fn size(self, size: i32) -> Self {
926 Self {
927 builder: self.builder.property("size", size),
928 }
929 }
930
931 pub fn size_points(self, size_points: f64) -> Self {
932 Self {
933 builder: self.builder.property("size-points", size_points),
934 }
935 }
936
937 pub fn size_set(self, size_set: bool) -> Self {
938 Self {
939 builder: self.builder.property("size-set", size_set),
940 }
941 }
942
943 pub fn stretch(self, stretch: pango::Stretch) -> Self {
944 Self {
945 builder: self.builder.property("stretch", stretch),
946 }
947 }
948
949 pub fn stretch_set(self, stretch_set: bool) -> Self {
950 Self {
951 builder: self.builder.property("stretch-set", stretch_set),
952 }
953 }
954
955 pub fn strikethrough(self, strikethrough: bool) -> Self {
956 Self {
957 builder: self.builder.property("strikethrough", strikethrough),
958 }
959 }
960
961 pub fn strikethrough_set(self, strikethrough_set: bool) -> Self {
962 Self {
963 builder: self
964 .builder
965 .property("strikethrough-set", strikethrough_set),
966 }
967 }
968
969 pub fn style(self, style: pango::Style) -> Self {
970 Self {
971 builder: self.builder.property("style", style),
972 }
973 }
974
975 pub fn style_set(self, style_set: bool) -> Self {
976 Self {
977 builder: self.builder.property("style-set", style_set),
978 }
979 }
980
981 pub fn text(self, text: impl Into<glib::GString>) -> Self {
982 Self {
983 builder: self.builder.property("text", text.into()),
984 }
985 }
986
987 pub fn underline(self, underline: pango::Underline) -> Self {
988 Self {
989 builder: self.builder.property("underline", underline),
990 }
991 }
992
993 pub fn underline_set(self, underline_set: bool) -> Self {
994 Self {
995 builder: self.builder.property("underline-set", underline_set),
996 }
997 }
998
999 pub fn variant(self, variant: pango::Variant) -> Self {
1000 Self {
1001 builder: self.builder.property("variant", variant),
1002 }
1003 }
1004
1005 pub fn variant_set(self, variant_set: bool) -> Self {
1006 Self {
1007 builder: self.builder.property("variant-set", variant_set),
1008 }
1009 }
1010
1011 pub fn weight(self, weight: i32) -> Self {
1012 Self {
1013 builder: self.builder.property("weight", weight),
1014 }
1015 }
1016
1017 pub fn weight_set(self, weight_set: bool) -> Self {
1018 Self {
1019 builder: self.builder.property("weight-set", weight_set),
1020 }
1021 }
1022
1023 /// The desired width of the cell, in characters. If this property is set to
1024 /// -1, the width will be calculated automatically, otherwise the cell will
1025 /// request either 3 characters or the property value, whichever is greater.
1026 pub fn width_chars(self, width_chars: i32) -> Self {
1027 Self {
1028 builder: self.builder.property("width-chars", width_chars),
1029 }
1030 }
1031
1032 /// Specifies how to break the string into multiple lines, if the cell
1033 /// renderer does not have enough room to display the entire string.
1034 /// This property has no effect unless the wrap-width property is set.
1035 pub fn wrap_mode(self, wrap_mode: pango::WrapMode) -> Self {
1036 Self {
1037 builder: self.builder.property("wrap-mode", wrap_mode),
1038 }
1039 }
1040
1041 /// Specifies the minimum width at which the text is wrapped. The wrap-mode property can
1042 /// be used to influence at what character positions the line breaks can be placed.
1043 /// Setting wrap-width to -1 turns wrapping off.
1044 pub fn wrap_width(self, wrap_width: i32) -> Self {
1045 Self {
1046 builder: self.builder.property("wrap-width", wrap_width),
1047 }
1048 }
1049
1050 pub fn cell_background(self, cell_background: impl Into<glib::GString>) -> Self {
1051 Self {
1052 builder: self
1053 .builder
1054 .property("cell-background", cell_background.into()),
1055 }
1056 }
1057
1058 /// Cell background as a [`gdk::RGBA`][crate::gdk::RGBA]
1059 pub fn cell_background_rgba(self, cell_background_rgba: &gdk::RGBA) -> Self {
1060 Self {
1061 builder: self
1062 .builder
1063 .property("cell-background-rgba", cell_background_rgba),
1064 }
1065 }
1066
1067 pub fn cell_background_set(self, cell_background_set: bool) -> Self {
1068 Self {
1069 builder: self
1070 .builder
1071 .property("cell-background-set", cell_background_set),
1072 }
1073 }
1074
1075 pub fn height(self, height: i32) -> Self {
1076 Self {
1077 builder: self.builder.property("height", height),
1078 }
1079 }
1080
1081 pub fn is_expanded(self, is_expanded: bool) -> Self {
1082 Self {
1083 builder: self.builder.property("is-expanded", is_expanded),
1084 }
1085 }
1086
1087 pub fn is_expander(self, is_expander: bool) -> Self {
1088 Self {
1089 builder: self.builder.property("is-expander", is_expander),
1090 }
1091 }
1092
1093 pub fn mode(self, mode: CellRendererMode) -> Self {
1094 Self {
1095 builder: self.builder.property("mode", mode),
1096 }
1097 }
1098
1099 pub fn sensitive(self, sensitive: bool) -> Self {
1100 Self {
1101 builder: self.builder.property("sensitive", sensitive),
1102 }
1103 }
1104
1105 pub fn visible(self, visible: bool) -> Self {
1106 Self {
1107 builder: self.builder.property("visible", visible),
1108 }
1109 }
1110
1111 pub fn width(self, width: i32) -> Self {
1112 Self {
1113 builder: self.builder.property("width", width),
1114 }
1115 }
1116
1117 pub fn xalign(self, xalign: f32) -> Self {
1118 Self {
1119 builder: self.builder.property("xalign", xalign),
1120 }
1121 }
1122
1123 pub fn xpad(self, xpad: u32) -> Self {
1124 Self {
1125 builder: self.builder.property("xpad", xpad),
1126 }
1127 }
1128
1129 pub fn yalign(self, yalign: f32) -> Self {
1130 Self {
1131 builder: self.builder.property("yalign", yalign),
1132 }
1133 }
1134
1135 pub fn ypad(self, ypad: u32) -> Self {
1136 Self {
1137 builder: self.builder.property("ypad", ypad),
1138 }
1139 }
1140
1141 // rustdoc-stripper-ignore-next
1142 /// Build the [`CellRendererAccel`].
1143 #[must_use = "Building the object from the builder is usually expensive and is not expected to have side effects"]
1144 pub fn build(self) -> CellRendererAccel {
1145 assert_initialized_main_thread!();
1146 self.builder.build()
1147 }
1148}