1 // Take a look at the license at the top of the repository in the LICENSE file.
2
3 use libc::{c_char, c_int};
4 use std::mem;
5
6 use glib::object::IsA;
7 use glib::subclass::prelude::*;
8 use glib::translate::*;
9 use glib::Cast;
10 use glib::GString;
11 use glib::Object;
12
13 use crate::CellEditable;
14 use crate::CellRenderer;
15 use crate::CellRendererState;
16 use crate::SizeRequestMode;
17 use crate::Widget;
18
19 pub trait CellRendererImpl: CellRendererImplExt + ObjectImpl {
request_mode(&self, renderer: &Self::Type) -> SizeRequestMode20 fn request_mode(&self, renderer: &Self::Type) -> SizeRequestMode {
21 self.parent_request_mode(renderer)
22 }
23
preferred_width<P: IsA<Widget>>(&self, renderer: &Self::Type, widget: &P) -> (i32, i32)24 fn preferred_width<P: IsA<Widget>>(&self, renderer: &Self::Type, widget: &P) -> (i32, i32) {
25 self.parent_preferred_width(renderer, widget)
26 }
27
28 #[doc(alias = "get_preferred_width_for_height")]
preferred_width_for_height<P: IsA<Widget>>( &self, renderer: &Self::Type, widget: &P, height: i32, ) -> (i32, i32)29 fn preferred_width_for_height<P: IsA<Widget>>(
30 &self,
31 renderer: &Self::Type,
32 widget: &P,
33 height: i32,
34 ) -> (i32, i32) {
35 self.parent_preferred_width_for_height(renderer, widget, height)
36 }
37
38 #[doc(alias = "get_preferred_height")]
preferred_height<P: IsA<Widget>>(&self, renderer: &Self::Type, widget: &P) -> (i32, i32)39 fn preferred_height<P: IsA<Widget>>(&self, renderer: &Self::Type, widget: &P) -> (i32, i32) {
40 self.parent_preferred_height(renderer, widget)
41 }
42
43 #[doc(alias = "get_preferred_height_for_width")]
preferred_height_for_width<P: IsA<Widget>>( &self, renderer: &Self::Type, widget: &P, width: i32, ) -> (i32, i32)44 fn preferred_height_for_width<P: IsA<Widget>>(
45 &self,
46 renderer: &Self::Type,
47 widget: &P,
48 width: i32,
49 ) -> (i32, i32) {
50 self.parent_preferred_height_for_width(renderer, widget, width)
51 }
52
53 #[doc(alias = "get_aligned_area")]
aligned_area<P: IsA<Widget>>( &self, renderer: &Self::Type, widget: &P, flags: CellRendererState, cell_area: &gdk::Rectangle, ) -> gdk::Rectangle54 fn aligned_area<P: IsA<Widget>>(
55 &self,
56 renderer: &Self::Type,
57 widget: &P,
58 flags: CellRendererState,
59 cell_area: &gdk::Rectangle,
60 ) -> gdk::Rectangle {
61 self.parent_aligned_area(renderer, widget, flags, cell_area)
62 }
63
render<P: IsA<Widget>>( &self, renderer: &Self::Type, cr: &cairo::Context, widget: &P, background_area: &gdk::Rectangle, cell_area: &gdk::Rectangle, flags: CellRendererState, )64 fn render<P: IsA<Widget>>(
65 &self,
66 renderer: &Self::Type,
67 cr: &cairo::Context,
68 widget: &P,
69 background_area: &gdk::Rectangle,
70 cell_area: &gdk::Rectangle,
71 flags: CellRendererState,
72 ) {
73 self.parent_render(renderer, cr, widget, background_area, cell_area, flags);
74 }
75
activate<P: IsA<Widget>>( &self, renderer: &Self::Type, event: Option<&gdk::Event>, widget: &P, path: &str, background_area: &gdk::Rectangle, cell_area: &gdk::Rectangle, flags: CellRendererState, ) -> bool76 fn activate<P: IsA<Widget>>(
77 &self,
78 renderer: &Self::Type,
79 event: Option<&gdk::Event>,
80 widget: &P,
81 path: &str,
82 background_area: &gdk::Rectangle,
83 cell_area: &gdk::Rectangle,
84 flags: CellRendererState,
85 ) -> bool {
86 self.parent_activate(
87 renderer,
88 event,
89 widget,
90 path,
91 background_area,
92 cell_area,
93 flags,
94 )
95 }
96
start_editing<P: IsA<Widget>>( &self, renderer: &Self::Type, event: Option<&gdk::Event>, widget: &P, path: &str, background_area: &gdk::Rectangle, cell_area: &gdk::Rectangle, flags: CellRendererState, ) -> Option<CellEditable>97 fn start_editing<P: IsA<Widget>>(
98 &self,
99 renderer: &Self::Type,
100 event: Option<&gdk::Event>,
101 widget: &P,
102 path: &str,
103 background_area: &gdk::Rectangle,
104 cell_area: &gdk::Rectangle,
105 flags: CellRendererState,
106 ) -> Option<CellEditable> {
107 self.parent_start_editing(
108 renderer,
109 event,
110 widget,
111 path,
112 background_area,
113 cell_area,
114 flags,
115 )
116 }
117
editing_canceled(&self, renderer: &Self::Type)118 fn editing_canceled(&self, renderer: &Self::Type) {
119 self.parent_editing_canceled(renderer)
120 }
121
editing_started(&self, renderer: &Self::Type, editable: &CellEditable, path: &str)122 fn editing_started(&self, renderer: &Self::Type, editable: &CellEditable, path: &str) {
123 self.parent_editing_started(renderer, editable, path)
124 }
125 }
126
127 pub trait CellRendererImplExt: ObjectSubclass {
parent_request_mode(&self, renderer: &Self::Type) -> SizeRequestMode128 fn parent_request_mode(&self, renderer: &Self::Type) -> SizeRequestMode;
parent_preferred_width<P: IsA<Widget>>( &self, renderer: &Self::Type, widget: &P, ) -> (i32, i32)129 fn parent_preferred_width<P: IsA<Widget>>(
130 &self,
131 renderer: &Self::Type,
132 widget: &P,
133 ) -> (i32, i32);
parent_preferred_width_for_height<P: IsA<Widget>>( &self, renderer: &Self::Type, widget: &P, height: i32, ) -> (i32, i32)134 fn parent_preferred_width_for_height<P: IsA<Widget>>(
135 &self,
136 renderer: &Self::Type,
137 widget: &P,
138 height: i32,
139 ) -> (i32, i32);
parent_preferred_height<P: IsA<Widget>>( &self, renderer: &Self::Type, widget: &P, ) -> (i32, i32)140 fn parent_preferred_height<P: IsA<Widget>>(
141 &self,
142 renderer: &Self::Type,
143 widget: &P,
144 ) -> (i32, i32);
parent_preferred_height_for_width<P: IsA<Widget>>( &self, renderer: &Self::Type, widget: &P, width: i32, ) -> (i32, i32)145 fn parent_preferred_height_for_width<P: IsA<Widget>>(
146 &self,
147 renderer: &Self::Type,
148 widget: &P,
149 width: i32,
150 ) -> (i32, i32);
parent_aligned_area<P: IsA<Widget>>( &self, renderer: &Self::Type, widget: &P, flags: CellRendererState, cell_area: &gdk::Rectangle, ) -> gdk::Rectangle151 fn parent_aligned_area<P: IsA<Widget>>(
152 &self,
153 renderer: &Self::Type,
154 widget: &P,
155 flags: CellRendererState,
156 cell_area: &gdk::Rectangle,
157 ) -> gdk::Rectangle;
parent_render<P: IsA<Widget>>( &self, renderer: &Self::Type, cr: &cairo::Context, widget: &P, background_area: &gdk::Rectangle, cell_area: &gdk::Rectangle, flags: CellRendererState, )158 fn parent_render<P: IsA<Widget>>(
159 &self,
160 renderer: &Self::Type,
161 cr: &cairo::Context,
162 widget: &P,
163 background_area: &gdk::Rectangle,
164 cell_area: &gdk::Rectangle,
165 flags: CellRendererState,
166 );
parent_activate<P: IsA<Widget>>( &self, renderer: &Self::Type, event: Option<&gdk::Event>, widget: &P, path: &str, background_area: &gdk::Rectangle, cell_area: &gdk::Rectangle, flags: CellRendererState, ) -> bool167 fn parent_activate<P: IsA<Widget>>(
168 &self,
169 renderer: &Self::Type,
170 event: Option<&gdk::Event>,
171 widget: &P,
172 path: &str,
173 background_area: &gdk::Rectangle,
174 cell_area: &gdk::Rectangle,
175 flags: CellRendererState,
176 ) -> bool;
parent_start_editing<P: IsA<Widget>>( &self, renderer: &Self::Type, event: Option<&gdk::Event>, widget: &P, path: &str, background_area: &gdk::Rectangle, cell_area: &gdk::Rectangle, flags: CellRendererState, ) -> Option<CellEditable>177 fn parent_start_editing<P: IsA<Widget>>(
178 &self,
179 renderer: &Self::Type,
180 event: Option<&gdk::Event>,
181 widget: &P,
182 path: &str,
183 background_area: &gdk::Rectangle,
184 cell_area: &gdk::Rectangle,
185 flags: CellRendererState,
186 ) -> Option<CellEditable>;
parent_editing_canceled(&self, renderer: &Self::Type)187 fn parent_editing_canceled(&self, renderer: &Self::Type);
parent_editing_started(&self, renderer: &Self::Type, editable: &CellEditable, path: &str)188 fn parent_editing_started(&self, renderer: &Self::Type, editable: &CellEditable, path: &str);
189 }
190
191 impl<T: CellRendererImpl> CellRendererImplExt for T {
parent_request_mode(&self, renderer: &Self::Type) -> SizeRequestMode192 fn parent_request_mode(&self, renderer: &Self::Type) -> SizeRequestMode {
193 unsafe {
194 let data = T::type_data();
195 let parent_class = data.as_ref().parent_class() as *mut ffi::GtkCellRendererClass;
196 let f = (*parent_class).get_request_mode.unwrap();
197 from_glib(f(renderer
198 .unsafe_cast_ref::<CellRenderer>()
199 .to_glib_none()
200 .0))
201 }
202 }
203
parent_preferred_width<P: IsA<Widget>>( &self, renderer: &Self::Type, widget: &P, ) -> (i32, i32)204 fn parent_preferred_width<P: IsA<Widget>>(
205 &self,
206 renderer: &Self::Type,
207 widget: &P,
208 ) -> (i32, i32) {
209 unsafe {
210 let data = T::type_data();
211 let parent_class = data.as_ref().parent_class() as *mut ffi::GtkCellRendererClass;
212 let f = (*parent_class).get_preferred_width.unwrap();
213
214 let mut minimum_size = mem::MaybeUninit::uninit();
215 let mut natural_size = mem::MaybeUninit::uninit();
216 f(
217 renderer.unsafe_cast_ref::<CellRenderer>().to_glib_none().0,
218 widget.as_ref().to_glib_none().0,
219 minimum_size.as_mut_ptr(),
220 natural_size.as_mut_ptr(),
221 );
222 (minimum_size.assume_init(), natural_size.assume_init())
223 }
224 }
225
parent_preferred_width_for_height<P: IsA<Widget>>( &self, renderer: &Self::Type, widget: &P, height: i32, ) -> (i32, i32)226 fn parent_preferred_width_for_height<P: IsA<Widget>>(
227 &self,
228 renderer: &Self::Type,
229 widget: &P,
230 height: i32,
231 ) -> (i32, i32) {
232 unsafe {
233 let data = T::type_data();
234 let parent_class = data.as_ref().parent_class() as *mut ffi::GtkCellRendererClass;
235 let f = (*parent_class).get_preferred_width_for_height.unwrap();
236
237 let mut minimum_size = mem::MaybeUninit::uninit();
238 let mut natural_size = mem::MaybeUninit::uninit();
239 f(
240 renderer.unsafe_cast_ref::<CellRenderer>().to_glib_none().0,
241 widget.as_ref().to_glib_none().0,
242 height,
243 minimum_size.as_mut_ptr(),
244 natural_size.as_mut_ptr(),
245 );
246 (minimum_size.assume_init(), natural_size.assume_init())
247 }
248 }
parent_preferred_height<P: IsA<Widget>>( &self, renderer: &Self::Type, widget: &P, ) -> (i32, i32)249 fn parent_preferred_height<P: IsA<Widget>>(
250 &self,
251 renderer: &Self::Type,
252 widget: &P,
253 ) -> (i32, i32) {
254 unsafe {
255 let data = T::type_data();
256 let parent_class = data.as_ref().parent_class() as *mut ffi::GtkCellRendererClass;
257 let f = (*parent_class).get_preferred_height.unwrap();
258 let mut minimum_size = mem::MaybeUninit::uninit();
259 let mut natural_size = mem::MaybeUninit::uninit();
260 f(
261 renderer.unsafe_cast_ref::<CellRenderer>().to_glib_none().0,
262 widget.as_ref().to_glib_none().0,
263 minimum_size.as_mut_ptr(),
264 natural_size.as_mut_ptr(),
265 );
266 (minimum_size.assume_init(), natural_size.assume_init())
267 }
268 }
parent_preferred_height_for_width<P: IsA<Widget>>( &self, renderer: &Self::Type, widget: &P, width: i32, ) -> (i32, i32)269 fn parent_preferred_height_for_width<P: IsA<Widget>>(
270 &self,
271 renderer: &Self::Type,
272 widget: &P,
273 width: i32,
274 ) -> (i32, i32) {
275 unsafe {
276 let data = T::type_data();
277 let parent_class = data.as_ref().parent_class() as *mut ffi::GtkCellRendererClass;
278 let f = (*parent_class).get_preferred_height_for_width.unwrap();
279 let mut minimum_size = mem::MaybeUninit::uninit();
280 let mut natural_size = mem::MaybeUninit::uninit();
281 f(
282 renderer.unsafe_cast_ref::<CellRenderer>().to_glib_none().0,
283 widget.as_ref().to_glib_none().0,
284 width,
285 minimum_size.as_mut_ptr(),
286 natural_size.as_mut_ptr(),
287 );
288 (minimum_size.assume_init(), natural_size.assume_init())
289 }
290 }
291
parent_aligned_area<P: IsA<Widget>>( &self, renderer: &Self::Type, widget: &P, flags: CellRendererState, cell_area: &gdk::Rectangle, ) -> gdk::Rectangle292 fn parent_aligned_area<P: IsA<Widget>>(
293 &self,
294 renderer: &Self::Type,
295 widget: &P,
296 flags: CellRendererState,
297 cell_area: &gdk::Rectangle,
298 ) -> gdk::Rectangle {
299 unsafe {
300 let data = T::type_data();
301 let parent_class = data.as_ref().parent_class() as *mut ffi::GtkCellRendererClass;
302 let mut aligned_area = gdk::Rectangle::uninitialized();
303 let f = (*parent_class).get_aligned_area.unwrap();
304 f(
305 renderer.unsafe_cast_ref::<CellRenderer>().to_glib_none().0,
306 widget.as_ref().to_glib_none().0,
307 flags.into_glib(),
308 cell_area.to_glib_none().0,
309 aligned_area.to_glib_none_mut().0,
310 );
311 aligned_area
312 }
313 }
314
parent_render<P: IsA<Widget>>( &self, renderer: &Self::Type, cr: &cairo::Context, widget: &P, background_area: &gdk::Rectangle, cell_area: &gdk::Rectangle, flags: CellRendererState, )315 fn parent_render<P: IsA<Widget>>(
316 &self,
317 renderer: &Self::Type,
318 cr: &cairo::Context,
319 widget: &P,
320 background_area: &gdk::Rectangle,
321 cell_area: &gdk::Rectangle,
322 flags: CellRendererState,
323 ) {
324 unsafe {
325 let data = T::type_data();
326 let parent_class = data.as_ref().parent_class() as *mut ffi::GtkCellRendererClass;
327 if let Some(f) = (*parent_class).render {
328 f(
329 renderer.unsafe_cast_ref::<CellRenderer>().to_glib_none().0,
330 cr.to_glib_none().0,
331 widget.as_ref().to_glib_none().0,
332 background_area.to_glib_none().0,
333 cell_area.to_glib_none().0,
334 flags.into_glib(),
335 )
336 }
337 }
338 }
339
parent_activate<P: IsA<Widget>>( &self, renderer: &Self::Type, event: Option<&gdk::Event>, widget: &P, path: &str, background_area: &gdk::Rectangle, cell_area: &gdk::Rectangle, flags: CellRendererState, ) -> bool340 fn parent_activate<P: IsA<Widget>>(
341 &self,
342 renderer: &Self::Type,
343 event: Option<&gdk::Event>,
344 widget: &P,
345 path: &str,
346 background_area: &gdk::Rectangle,
347 cell_area: &gdk::Rectangle,
348 flags: CellRendererState,
349 ) -> bool {
350 unsafe {
351 let data = T::type_data();
352 let parent_class = data.as_ref().parent_class() as *mut ffi::GtkCellRendererClass;
353 if let Some(f) = (*parent_class).activate {
354 from_glib(f(
355 renderer.unsafe_cast_ref::<CellRenderer>().to_glib_none().0,
356 mut_override(event.to_glib_none().0),
357 widget.as_ref().to_glib_none().0,
358 path.to_glib_none().0,
359 background_area.to_glib_none().0,
360 cell_area.to_glib_none().0,
361 flags.into_glib(),
362 ))
363 } else {
364 false
365 }
366 }
367 }
368
parent_start_editing<P: IsA<Widget>>( &self, renderer: &Self::Type, event: Option<&gdk::Event>, widget: &P, path: &str, background_area: &gdk::Rectangle, cell_area: &gdk::Rectangle, flags: CellRendererState, ) -> Option<CellEditable>369 fn parent_start_editing<P: IsA<Widget>>(
370 &self,
371 renderer: &Self::Type,
372 event: Option<&gdk::Event>,
373 widget: &P,
374 path: &str,
375 background_area: &gdk::Rectangle,
376 cell_area: &gdk::Rectangle,
377 flags: CellRendererState,
378 ) -> Option<CellEditable> {
379 unsafe {
380 let data = T::type_data();
381 let parent_class = data.as_ref().parent_class() as *mut ffi::GtkCellRendererClass;
382 if let Some(f) = (*parent_class).start_editing {
383 from_glib_none(f(
384 renderer.unsafe_cast_ref::<CellRenderer>().to_glib_none().0,
385 mut_override(event.to_glib_none().0),
386 widget.as_ref().to_glib_none().0,
387 path.to_glib_none().0,
388 background_area.to_glib_none().0,
389 cell_area.to_glib_none().0,
390 flags.into_glib(),
391 ))
392 } else {
393 None
394 }
395 }
396 }
397
parent_editing_canceled(&self, renderer: &Self::Type)398 fn parent_editing_canceled(&self, renderer: &Self::Type) {
399 unsafe {
400 let data = T::type_data();
401 let parent_class = data.as_ref().parent_class() as *mut ffi::GtkCellRendererClass;
402 if let Some(f) = (*parent_class).editing_canceled {
403 f(renderer.unsafe_cast_ref::<CellRenderer>().to_glib_none().0)
404 }
405 }
406 }
407
parent_editing_started(&self, renderer: &Self::Type, editable: &CellEditable, path: &str)408 fn parent_editing_started(&self, renderer: &Self::Type, editable: &CellEditable, path: &str) {
409 unsafe {
410 let data = T::type_data();
411 let parent_class = data.as_ref().parent_class() as *mut ffi::GtkCellRendererClass;
412 if let Some(f) = (*parent_class).editing_started {
413 f(
414 renderer.unsafe_cast_ref::<CellRenderer>().to_glib_none().0,
415 editable.to_glib_none().0,
416 path.to_glib_none().0,
417 )
418 }
419 }
420 }
421 }
422
423 unsafe impl<T: CellRendererImpl> IsSubclassable<T> for CellRenderer {
class_init(class: &mut ::glib::Class<Self>)424 fn class_init(class: &mut ::glib::Class<Self>) {
425 <Object as IsSubclassable<T>>::class_init(class);
426
427 let klass = class.as_mut();
428 klass.get_request_mode = Some(cell_renderer_get_request_mode::<T>);
429 klass.get_preferred_width = Some(cell_renderer_get_preferred_width::<T>);
430 klass.get_preferred_height_for_width =
431 Some(cell_renderer_get_preferred_height_for_width::<T>);
432 klass.get_preferred_height = Some(cell_renderer_get_preferred_height::<T>);
433 klass.get_preferred_width_for_height =
434 Some(cell_renderer_get_preferred_width_for_height::<T>);
435 klass.get_aligned_area = Some(cell_renderer_get_aligned_area::<T>);
436 klass.render = Some(cell_renderer_render::<T>);
437 klass.activate = Some(cell_renderer_activate::<T>);
438 klass.start_editing = Some(cell_renderer_start_editing::<T>);
439 klass.editing_started = Some(cell_renderer_editing_started::<T>);
440 klass.editing_canceled = Some(cell_renderer_editing_canceled::<T>);
441 }
442
instance_init(instance: &mut glib::subclass::InitializingObject<T>)443 fn instance_init(instance: &mut glib::subclass::InitializingObject<T>) {
444 <Object as IsSubclassable<T>>::instance_init(instance);
445 }
446 }
447
cell_renderer_get_request_mode<T: CellRendererImpl>( ptr: *mut ffi::GtkCellRenderer, ) -> ffi::GtkSizeRequestMode448 unsafe extern "C" fn cell_renderer_get_request_mode<T: CellRendererImpl>(
449 ptr: *mut ffi::GtkCellRenderer,
450 ) -> ffi::GtkSizeRequestMode {
451 let instance = &*(ptr as *mut T::Instance);
452 let imp = instance.impl_();
453 let wrap: Borrowed<CellRenderer> = from_glib_borrow(ptr);
454
455 imp.request_mode(wrap.unsafe_cast_ref()).into_glib()
456 }
457
cell_renderer_get_preferred_width<T: CellRendererImpl>( ptr: *mut ffi::GtkCellRenderer, wdgtptr: *mut ffi::GtkWidget, minptr: *mut c_int, natptr: *mut c_int, )458 unsafe extern "C" fn cell_renderer_get_preferred_width<T: CellRendererImpl>(
459 ptr: *mut ffi::GtkCellRenderer,
460 wdgtptr: *mut ffi::GtkWidget,
461 minptr: *mut c_int,
462 natptr: *mut c_int,
463 ) {
464 let instance = &*(ptr as *mut T::Instance);
465 let imp = instance.impl_();
466 let wrap: Borrowed<CellRenderer> = from_glib_borrow(ptr);
467 let widget: Borrowed<Widget> = from_glib_borrow(wdgtptr);
468
469 let (min_size, nat_size) = imp.preferred_width(wrap.unsafe_cast_ref(), &*widget);
470 if !minptr.is_null() {
471 *minptr = min_size;
472 }
473 if !natptr.is_null() {
474 *natptr = nat_size;
475 }
476 }
477
cell_renderer_get_preferred_height_for_width<T: CellRendererImpl>( ptr: *mut ffi::GtkCellRenderer, wdgtptr: *mut ffi::GtkWidget, width: c_int, min_height_ptr: *mut c_int, nat_height_ptr: *mut c_int, )478 unsafe extern "C" fn cell_renderer_get_preferred_height_for_width<T: CellRendererImpl>(
479 ptr: *mut ffi::GtkCellRenderer,
480 wdgtptr: *mut ffi::GtkWidget,
481 width: c_int,
482 min_height_ptr: *mut c_int,
483 nat_height_ptr: *mut c_int,
484 ) {
485 let instance = &*(ptr as *mut T::Instance);
486 let imp = instance.impl_();
487 let wrap: Borrowed<CellRenderer> = from_glib_borrow(ptr);
488 let widget: Borrowed<Widget> = from_glib_borrow(wdgtptr);
489
490 let (min_height, nat_height) =
491 imp.preferred_height_for_width(wrap.unsafe_cast_ref(), &*widget, width);
492 if !min_height_ptr.is_null() {
493 *min_height_ptr = min_height;
494 }
495 if !nat_height_ptr.is_null() {
496 *nat_height_ptr = nat_height;
497 }
498 }
499
cell_renderer_get_preferred_height<T: CellRendererImpl>( ptr: *mut ffi::GtkCellRenderer, wdgtptr: *mut ffi::GtkWidget, minptr: *mut c_int, natptr: *mut c_int, )500 unsafe extern "C" fn cell_renderer_get_preferred_height<T: CellRendererImpl>(
501 ptr: *mut ffi::GtkCellRenderer,
502 wdgtptr: *mut ffi::GtkWidget,
503 minptr: *mut c_int,
504 natptr: *mut c_int,
505 ) {
506 let instance = &*(ptr as *mut T::Instance);
507 let imp = instance.impl_();
508 let wrap: Borrowed<CellRenderer> = from_glib_borrow(ptr);
509 let widget: Borrowed<Widget> = from_glib_borrow(wdgtptr);
510
511 let (min_size, nat_size) = imp.preferred_height(wrap.unsafe_cast_ref(), &*widget);
512 if !minptr.is_null() {
513 *minptr = min_size;
514 }
515 if !natptr.is_null() {
516 *natptr = nat_size;
517 }
518 }
519
cell_renderer_get_preferred_width_for_height<T: CellRendererImpl>( ptr: *mut ffi::GtkCellRenderer, wdgtptr: *mut ffi::GtkWidget, height: c_int, min_width_ptr: *mut c_int, nat_width_ptr: *mut c_int, )520 unsafe extern "C" fn cell_renderer_get_preferred_width_for_height<T: CellRendererImpl>(
521 ptr: *mut ffi::GtkCellRenderer,
522 wdgtptr: *mut ffi::GtkWidget,
523 height: c_int,
524 min_width_ptr: *mut c_int,
525 nat_width_ptr: *mut c_int,
526 ) {
527 let instance = &*(ptr as *mut T::Instance);
528 let imp = instance.impl_();
529 let wrap: Borrowed<CellRenderer> = from_glib_borrow(ptr);
530 let widget: Borrowed<Widget> = from_glib_borrow(wdgtptr);
531
532 let (min_width, nat_width) =
533 imp.preferred_width_for_height(wrap.unsafe_cast_ref(), &*widget, height);
534 if !min_width_ptr.is_null() {
535 *min_width_ptr = min_width;
536 }
537 if !nat_width_ptr.is_null() {
538 *nat_width_ptr = nat_width;
539 }
540 }
541
cell_renderer_get_aligned_area<T: CellRendererImpl>( ptr: *mut ffi::GtkCellRenderer, wdgtptr: *mut ffi::GtkWidget, flags: ffi::GtkCellRendererState, cellarea: *const gdk::ffi::GdkRectangle, alignedptr: *mut gdk::ffi::GdkRectangle, )542 unsafe extern "C" fn cell_renderer_get_aligned_area<T: CellRendererImpl>(
543 ptr: *mut ffi::GtkCellRenderer,
544 wdgtptr: *mut ffi::GtkWidget,
545 flags: ffi::GtkCellRendererState,
546 cellarea: *const gdk::ffi::GdkRectangle,
547 alignedptr: *mut gdk::ffi::GdkRectangle,
548 ) {
549 let instance = &*(ptr as *mut T::Instance);
550 let imp = instance.impl_();
551 let wrap: Borrowed<CellRenderer> = from_glib_borrow(ptr);
552 let widget: Borrowed<Widget> = from_glib_borrow(wdgtptr);
553
554 let rectangle = imp.aligned_area(
555 wrap.unsafe_cast_ref(),
556 &*widget,
557 from_glib(flags),
558 &from_glib_borrow(cellarea),
559 );
560 *alignedptr = *rectangle.to_glib_none().0;
561 }
562
cell_renderer_render<T: CellRendererImpl>( ptr: *mut ffi::GtkCellRenderer, crptr: *mut cairo::ffi::cairo_t, wdgtptr: *mut ffi::GtkWidget, bgptr: *const gdk::ffi::GdkRectangle, cellptr: *const gdk::ffi::GdkRectangle, flags: ffi::GtkCellRendererState, )563 unsafe extern "C" fn cell_renderer_render<T: CellRendererImpl>(
564 ptr: *mut ffi::GtkCellRenderer,
565 crptr: *mut cairo::ffi::cairo_t,
566 wdgtptr: *mut ffi::GtkWidget,
567 bgptr: *const gdk::ffi::GdkRectangle,
568 cellptr: *const gdk::ffi::GdkRectangle,
569 flags: ffi::GtkCellRendererState,
570 ) {
571 let instance = &*(ptr as *mut T::Instance);
572 let imp = instance.impl_();
573 let wrap: Borrowed<CellRenderer> = from_glib_borrow(ptr);
574 let widget: Borrowed<Widget> = from_glib_borrow(wdgtptr);
575 let cr: Borrowed<cairo::Context> = from_glib_borrow(crptr);
576
577 imp.render(
578 wrap.unsafe_cast_ref(),
579 &cr,
580 &*widget,
581 &from_glib_borrow(bgptr),
582 &from_glib_borrow(cellptr),
583 from_glib(flags),
584 );
585 }
586
cell_renderer_activate<T: CellRendererImpl>( ptr: *mut ffi::GtkCellRenderer, evtptr: *mut gdk::ffi::GdkEvent, wdgtptr: *mut ffi::GtkWidget, pathptr: *const c_char, bgptr: *const gdk::ffi::GdkRectangle, cellptr: *const gdk::ffi::GdkRectangle, flags: ffi::GtkCellRendererState, ) -> glib::ffi::gboolean587 unsafe extern "C" fn cell_renderer_activate<T: CellRendererImpl>(
588 ptr: *mut ffi::GtkCellRenderer,
589 evtptr: *mut gdk::ffi::GdkEvent,
590 wdgtptr: *mut ffi::GtkWidget,
591 pathptr: *const c_char,
592 bgptr: *const gdk::ffi::GdkRectangle,
593 cellptr: *const gdk::ffi::GdkRectangle,
594 flags: ffi::GtkCellRendererState,
595 ) -> glib::ffi::gboolean {
596 let instance = &*(ptr as *mut T::Instance);
597 let imp = instance.impl_();
598 let wrap: Borrowed<CellRenderer> = from_glib_borrow(ptr);
599 let widget: Borrowed<Widget> = from_glib_borrow(wdgtptr);
600 let evt: Borrowed<Option<gdk::Event>> = from_glib_borrow(evtptr);
601
602 imp.activate(
603 wrap.unsafe_cast_ref(),
604 evt.as_ref().as_ref(),
605 &*widget,
606 &GString::from_glib_borrow(pathptr),
607 &from_glib_borrow(bgptr),
608 &from_glib_borrow(cellptr),
609 from_glib(flags),
610 )
611 .into_glib()
612 }
613
cell_renderer_start_editing<T: CellRendererImpl>( ptr: *mut ffi::GtkCellRenderer, evtptr: *mut gdk::ffi::GdkEvent, wdgtptr: *mut ffi::GtkWidget, pathptr: *const c_char, bgptr: *const gdk::ffi::GdkRectangle, cellptr: *const gdk::ffi::GdkRectangle, flags: ffi::GtkCellRendererState, ) -> *mut ffi::GtkCellEditable614 unsafe extern "C" fn cell_renderer_start_editing<T: CellRendererImpl>(
615 ptr: *mut ffi::GtkCellRenderer,
616 evtptr: *mut gdk::ffi::GdkEvent,
617 wdgtptr: *mut ffi::GtkWidget,
618 pathptr: *const c_char,
619 bgptr: *const gdk::ffi::GdkRectangle,
620 cellptr: *const gdk::ffi::GdkRectangle,
621 flags: ffi::GtkCellRendererState,
622 ) -> *mut ffi::GtkCellEditable {
623 let instance = &*(ptr as *mut T::Instance);
624 let imp = instance.impl_();
625 let wrap: Borrowed<CellRenderer> = from_glib_borrow(ptr);
626 let widget: Borrowed<Widget> = from_glib_borrow(wdgtptr);
627 let evt: Borrowed<Option<gdk::Event>> = from_glib_borrow(evtptr);
628
629 imp.start_editing(
630 wrap.unsafe_cast_ref(),
631 evt.as_ref().as_ref(),
632 &*widget,
633 &GString::from_glib_borrow(pathptr),
634 &from_glib_borrow(bgptr),
635 &from_glib_borrow(cellptr),
636 from_glib(flags),
637 )
638 .to_glib_none()
639 .0
640 }
641
cell_renderer_editing_canceled<T: CellRendererImpl>( ptr: *mut ffi::GtkCellRenderer, )642 unsafe extern "C" fn cell_renderer_editing_canceled<T: CellRendererImpl>(
643 ptr: *mut ffi::GtkCellRenderer,
644 ) {
645 let instance = &*(ptr as *mut T::Instance);
646 let imp = instance.impl_();
647 let wrap: Borrowed<CellRenderer> = from_glib_borrow(ptr);
648
649 imp.editing_canceled(wrap.unsafe_cast_ref());
650 }
651
cell_renderer_editing_started<T: CellRendererImpl>( ptr: *mut ffi::GtkCellRenderer, editableptr: *mut ffi::GtkCellEditable, pathptr: *const c_char, )652 unsafe extern "C" fn cell_renderer_editing_started<T: CellRendererImpl>(
653 ptr: *mut ffi::GtkCellRenderer,
654 editableptr: *mut ffi::GtkCellEditable,
655 pathptr: *const c_char,
656 ) {
657 let instance = &*(ptr as *mut T::Instance);
658 let imp = instance.impl_();
659 let wrap: Borrowed<CellRenderer> = from_glib_borrow(ptr);
660 let editable = from_glib_borrow(editableptr);
661
662 imp.editing_started(
663 wrap.unsafe_cast_ref(),
664 &editable,
665 &GString::from_glib_borrow(pathptr),
666 );
667 }
668