1use std::cell::Cell;
3use std::rc::Rc;
4
5#[allow(unused_imports)]
6use std::marker::PhantomData;
7
8#[allow(unused_imports)]
9use std::os::raw::c_void;
10
11#[allow(unused_imports)]
12use std::mem::transmute;
13
14#[allow(unused_imports)]
15use std::ffi::{CStr, CString};
16
17use rute_ffi_base::*;
18
19#[allow(unused_imports)]
20use auto::*;
21
22#[derive(Clone)]
66pub struct Bitmap<'a> {
67 #[doc(hidden)]
68 pub data: Rc<Cell<Option<*const RUBase>>>,
69 #[doc(hidden)]
70 pub all_funcs: *const RUBitmapAllFuncs,
71 #[doc(hidden)]
72 pub owned: bool,
73 #[doc(hidden)]
74 pub _marker: PhantomData<::std::cell::Cell<&'a ()>>,
75}
76
77impl<'a> Bitmap<'a> {
78 pub fn new() -> Bitmap<'a> {
79 let ffi_data = unsafe { ((*rute_ffi_get()).create_bitmap)(::std::ptr::null()) };
80 Bitmap {
81 data: Rc::new(Cell::new(Some(ffi_data.qt_data))),
82 all_funcs: ffi_data.all_funcs,
83 owned: true,
84 _marker: PhantomData,
85 }
86 }
87 #[allow(dead_code)]
88 pub(crate) fn new_from_rc(ffi_data: RUBitmap) -> Bitmap<'a> {
89 Bitmap {
90 data: unsafe { Rc::from_raw(ffi_data.host_data as *const Cell<Option<*const RUBase>>) },
91 all_funcs: ffi_data.all_funcs,
92 owned: false,
93 _marker: PhantomData,
94 }
95 }
96
97 #[allow(dead_code)]
98 pub(crate) fn new_from_owned(ffi_data: RUBitmap) -> Bitmap<'a> {
99 Bitmap {
100 data: Rc::new(Cell::new(Some(ffi_data.qt_data as *const RUBase))),
101 all_funcs: ffi_data.all_funcs,
102 owned: true,
103 _marker: PhantomData,
104 }
105 }
106
107 #[allow(dead_code)]
108 pub(crate) fn new_from_temporary(ffi_data: RUBitmap) -> Bitmap<'a> {
109 Bitmap {
110 data: Rc::new(Cell::new(Some(ffi_data.qt_data as *const RUBase))),
111 all_funcs: ffi_data.all_funcs,
112 owned: false,
113 _marker: PhantomData,
114 }
115 }
116 pub fn swap<B: BitmapTrait<'a>>(&self, other: &B) -> &Self {
120 let (obj_other_1, _funcs) = other.get_bitmap_obj_funcs();
121
122 let (obj_data, funcs) = self.get_bitmap_obj_funcs();
123 unsafe {
124 ((*funcs).swap)(obj_data, obj_other_1);
125 }
126 self
127 }
128 pub fn clear(&self) -> &Self {
131 let (obj_data, funcs) = self.get_bitmap_obj_funcs();
132 unsafe {
133 ((*funcs).clear)(obj_data);
134 }
135 self
136 }
137 pub fn from_image<I: ImageTrait<'a>>(image: &I, flags: ImageConversionFlags) -> Bitmap<'a> {
143 let (obj_image_1, _funcs) = image.get_image_obj_funcs();
144 let enum_flags_2 = flags.bits();
145
146 let (obj_data, funcs) = unsafe {
147 (
148 ::std::ptr::null(),
149 (*((*rute_ffi_get()).get_bitmap)(::std::ptr::null()).all_funcs).bitmap_funcs,
150 )
151 };
152 unsafe {
153 let ret_val = ((*funcs).from_image)(obj_data, obj_image_1, enum_flags_2);
154 let t = ret_val;
155 let ret_val;
156 if t.host_data != ::std::ptr::null() {
157 ret_val = Bitmap::new_from_rc(t);
158 } else {
159 ret_val = Bitmap::new_from_owned(t);
160 }
161 ret_val
162 }
163 }
164 #[doc(hidden)]
165 pub fn is_null(&self) -> bool {
166 let (obj_data, funcs) = self.get_pixmap_obj_funcs();
167 unsafe {
168 let ret_val = ((*funcs).is_null)(obj_data);
169 ret_val
170 }
171 }
172 #[doc(hidden)]
173 pub fn width(&self) -> i32 {
174 let (obj_data, funcs) = self.get_pixmap_obj_funcs();
175 unsafe {
176 let ret_val = ((*funcs).width)(obj_data);
177 ret_val
178 }
179 }
180 #[doc(hidden)]
181 pub fn height(&self) -> i32 {
182 let (obj_data, funcs) = self.get_pixmap_obj_funcs();
183 unsafe {
184 let ret_val = ((*funcs).height)(obj_data);
185 ret_val
186 }
187 }
188 #[doc(hidden)]
189 pub fn size(&self) -> Size {
190 let (obj_data, funcs) = self.get_pixmap_obj_funcs();
191 unsafe {
192 let ret_val = ((*funcs).size)(obj_data);
193 let t = ret_val;
194 let ret_val;
195 if t.host_data != ::std::ptr::null() {
196 ret_val = Size::new_from_rc(t);
197 } else {
198 ret_val = Size::new_from_owned(t);
199 }
200 ret_val
201 }
202 }
203 #[doc(hidden)]
204 pub fn rect(&self) -> Rect {
205 let (obj_data, funcs) = self.get_pixmap_obj_funcs();
206 unsafe {
207 let ret_val = ((*funcs).rect)(obj_data);
208 let t = ret_val;
209 let ret_val;
210 if t.host_data != ::std::ptr::null() {
211 ret_val = Rect::new_from_rc(t);
212 } else {
213 ret_val = Rect::new_from_owned(t);
214 }
215 ret_val
216 }
217 }
218 #[doc(hidden)]
219 pub fn depth(&self) -> i32 {
220 let (obj_data, funcs) = self.get_pixmap_obj_funcs();
221 unsafe {
222 let ret_val = ((*funcs).depth)(obj_data);
223 ret_val
224 }
225 }
226 #[doc(hidden)]
227 pub fn default_depth() -> i32 {
228 let (obj_data, funcs) = unsafe {
229 (
230 ::std::ptr::null(),
231 (*((*rute_ffi_get()).get_pixmap)(::std::ptr::null()).all_funcs).pixmap_funcs,
232 )
233 };
234 unsafe {
235 let ret_val = ((*funcs).default_depth)(obj_data);
236 ret_val
237 }
238 }
239 #[doc(hidden)]
240 pub fn fill<C: ColorTrait<'a>>(&self, fill_color: &C) -> &Self {
241 let (obj_fill_color_1, _funcs) = fill_color.get_color_obj_funcs();
242
243 let (obj_data, funcs) = self.get_pixmap_obj_funcs();
244 unsafe {
245 ((*funcs).fill)(obj_data, obj_fill_color_1);
246 }
247 self
248 }
249 #[doc(hidden)]
250 pub fn fill_2<P: PaintDeviceTrait<'a>, Q: PointTrait<'a>>(&self, device: &P, ofs: &Q) -> &Self {
251 let (obj_device_1, _funcs) = device.get_paint_device_obj_funcs();
252 let (obj_ofs_2, _funcs) = ofs.get_point_obj_funcs();
253
254 let (obj_data, funcs) = self.get_pixmap_obj_funcs();
255 unsafe {
256 ((*funcs).fill_2)(obj_data, obj_device_1, obj_ofs_2);
257 }
258 self
259 }
260 #[doc(hidden)]
261 pub fn fill_3<P: PaintDeviceTrait<'a>>(&self, device: &P, xofs: i32, yofs: i32) -> &Self {
262 let (obj_device_1, _funcs) = device.get_paint_device_obj_funcs();
263
264 let (obj_data, funcs) = self.get_pixmap_obj_funcs();
265 unsafe {
266 ((*funcs).fill_3)(obj_data, obj_device_1, xofs, yofs);
267 }
268 self
269 }
270 #[doc(hidden)]
271 pub fn mask(&self) -> Bitmap {
272 let (obj_data, funcs) = self.get_pixmap_obj_funcs();
273 unsafe {
274 let ret_val = ((*funcs).mask)(obj_data);
275 let t = ret_val;
276 let ret_val;
277 if t.host_data != ::std::ptr::null() {
278 ret_val = Bitmap::new_from_rc(t);
279 } else {
280 ret_val = Bitmap::new_from_owned(t);
281 }
282 ret_val
283 }
284 }
285 #[doc(hidden)]
286 pub fn set_mask<B: BitmapTrait<'a>>(&self, arg0: &B) -> &Self {
287 let (obj_arg0_1, _funcs) = arg0.get_bitmap_obj_funcs();
288
289 let (obj_data, funcs) = self.get_pixmap_obj_funcs();
290 unsafe {
291 ((*funcs).set_mask)(obj_data, obj_arg0_1);
292 }
293 self
294 }
295 #[doc(hidden)]
296 pub fn device_pixel_ratio(&self) -> f32 {
297 let (obj_data, funcs) = self.get_pixmap_obj_funcs();
298 unsafe {
299 let ret_val = ((*funcs).device_pixel_ratio)(obj_data);
300 ret_val
301 }
302 }
303 #[doc(hidden)]
304 pub fn set_device_pixel_ratio(&self, scale_factor: f32) -> &Self {
305 let (obj_data, funcs) = self.get_pixmap_obj_funcs();
306 unsafe {
307 ((*funcs).set_device_pixel_ratio)(obj_data, scale_factor);
308 }
309 self
310 }
311 #[doc(hidden)]
312 pub fn has_alpha(&self) -> bool {
313 let (obj_data, funcs) = self.get_pixmap_obj_funcs();
314 unsafe {
315 let ret_val = ((*funcs).has_alpha)(obj_data);
316 ret_val
317 }
318 }
319 #[doc(hidden)]
320 pub fn has_alpha_channel(&self) -> bool {
321 let (obj_data, funcs) = self.get_pixmap_obj_funcs();
322 unsafe {
323 let ret_val = ((*funcs).has_alpha_channel)(obj_data);
324 ret_val
325 }
326 }
327 #[doc(hidden)]
328 pub fn create_heuristic_mask(&self, clip_tight: bool) -> Bitmap {
329 let (obj_data, funcs) = self.get_pixmap_obj_funcs();
330 unsafe {
331 let ret_val = ((*funcs).create_heuristic_mask)(obj_data, clip_tight);
332 let t = ret_val;
333 let ret_val;
334 if t.host_data != ::std::ptr::null() {
335 ret_val = Bitmap::new_from_rc(t);
336 } else {
337 ret_val = Bitmap::new_from_owned(t);
338 }
339 ret_val
340 }
341 }
342 #[doc(hidden)]
343 pub fn create_mask_from_color<C: ColorTrait<'a>>(
344 &self,
345 mask_color: &C,
346 mode: MaskMode,
347 ) -> Bitmap {
348 let (obj_mask_color_1, _funcs) = mask_color.get_color_obj_funcs();
349 let enum_mode_2 = mode as u32;
350
351 let (obj_data, funcs) = self.get_pixmap_obj_funcs();
352 unsafe {
353 let ret_val =
354 ((*funcs).create_mask_from_color)(obj_data, obj_mask_color_1, enum_mode_2);
355 let t = ret_val;
356 let ret_val;
357 if t.host_data != ::std::ptr::null() {
358 ret_val = Bitmap::new_from_rc(t);
359 } else {
360 ret_val = Bitmap::new_from_owned(t);
361 }
362 ret_val
363 }
364 }
365 #[doc(hidden)]
366 pub fn grab_window(arg0: u64, x: i32, y: i32, w: i32, h: i32) -> Pixmap<'a> {
367 let (obj_data, funcs) = unsafe {
368 (
369 ::std::ptr::null(),
370 (*((*rute_ffi_get()).get_pixmap)(::std::ptr::null()).all_funcs).pixmap_funcs,
371 )
372 };
373 unsafe {
374 let ret_val = ((*funcs).grab_window)(obj_data, arg0, x, y, w, h);
375 let t = ret_val;
376 let ret_val;
377 if t.host_data != ::std::ptr::null() {
378 ret_val = Pixmap::new_from_rc(t);
379 } else {
380 ret_val = Pixmap::new_from_owned(t);
381 }
382 ret_val
383 }
384 }
385 #[doc(hidden)]
386 pub fn grab_widget<O: ObjectTrait<'a>, R: RectTrait<'a>>(widget: &O, rect: &R) -> Pixmap<'a> {
387 let (obj_widget_1, _funcs) = widget.get_object_obj_funcs();
388 let (obj_rect_2, _funcs) = rect.get_rect_obj_funcs();
389
390 let (obj_data, funcs) = unsafe {
391 (
392 ::std::ptr::null(),
393 (*((*rute_ffi_get()).get_pixmap)(::std::ptr::null()).all_funcs).pixmap_funcs,
394 )
395 };
396 unsafe {
397 let ret_val = ((*funcs).grab_widget)(obj_data, obj_widget_1, obj_rect_2);
398 let t = ret_val;
399 let ret_val;
400 if t.host_data != ::std::ptr::null() {
401 ret_val = Pixmap::new_from_rc(t);
402 } else {
403 ret_val = Pixmap::new_from_owned(t);
404 }
405 ret_val
406 }
407 }
408 #[doc(hidden)]
409 pub fn grab_widget_2<O: ObjectTrait<'a>>(
410 widget: &O,
411 x: i32,
412 y: i32,
413 w: i32,
414 h: i32,
415 ) -> Pixmap<'a> {
416 let (obj_widget_1, _funcs) = widget.get_object_obj_funcs();
417
418 let (obj_data, funcs) = unsafe {
419 (
420 ::std::ptr::null(),
421 (*((*rute_ffi_get()).get_pixmap)(::std::ptr::null()).all_funcs).pixmap_funcs,
422 )
423 };
424 unsafe {
425 let ret_val = ((*funcs).grab_widget_2)(obj_data, obj_widget_1, x, y, w, h);
426 let t = ret_val;
427 let ret_val;
428 if t.host_data != ::std::ptr::null() {
429 ret_val = Pixmap::new_from_rc(t);
430 } else {
431 ret_val = Pixmap::new_from_owned(t);
432 }
433 ret_val
434 }
435 }
436 #[doc(hidden)]
437 pub fn scaled(
438 &self,
439 w: i32,
440 h: i32,
441 aspect_mode: AspectRatioMode,
442 mode: TransformationMode,
443 ) -> Pixmap {
444 let enum_aspect_mode_3 = aspect_mode as u32;
445 let enum_mode_4 = mode as u32;
446
447 let (obj_data, funcs) = self.get_pixmap_obj_funcs();
448 unsafe {
449 let ret_val = ((*funcs).scaled)(obj_data, w, h, enum_aspect_mode_3, enum_mode_4);
450 let t = ret_val;
451 let ret_val;
452 if t.host_data != ::std::ptr::null() {
453 ret_val = Pixmap::new_from_rc(t);
454 } else {
455 ret_val = Pixmap::new_from_owned(t);
456 }
457 ret_val
458 }
459 }
460 #[doc(hidden)]
461 pub fn scaled_2<S: SizeTrait<'a>>(
462 &self,
463 s: &S,
464 aspect_mode: AspectRatioMode,
465 mode: TransformationMode,
466 ) -> Pixmap {
467 let (obj_s_1, _funcs) = s.get_size_obj_funcs();
468 let enum_aspect_mode_2 = aspect_mode as u32;
469 let enum_mode_3 = mode as u32;
470
471 let (obj_data, funcs) = self.get_pixmap_obj_funcs();
472 unsafe {
473 let ret_val = ((*funcs).scaled_2)(obj_data, obj_s_1, enum_aspect_mode_2, enum_mode_3);
474 let t = ret_val;
475 let ret_val;
476 if t.host_data != ::std::ptr::null() {
477 ret_val = Pixmap::new_from_rc(t);
478 } else {
479 ret_val = Pixmap::new_from_owned(t);
480 }
481 ret_val
482 }
483 }
484 #[doc(hidden)]
485 pub fn scaled_to_width(&self, w: i32, mode: TransformationMode) -> Pixmap {
486 let enum_mode_2 = mode as u32;
487
488 let (obj_data, funcs) = self.get_pixmap_obj_funcs();
489 unsafe {
490 let ret_val = ((*funcs).scaled_to_width)(obj_data, w, enum_mode_2);
491 let t = ret_val;
492 let ret_val;
493 if t.host_data != ::std::ptr::null() {
494 ret_val = Pixmap::new_from_rc(t);
495 } else {
496 ret_val = Pixmap::new_from_owned(t);
497 }
498 ret_val
499 }
500 }
501 #[doc(hidden)]
502 pub fn scaled_to_height(&self, h: i32, mode: TransformationMode) -> Pixmap {
503 let enum_mode_2 = mode as u32;
504
505 let (obj_data, funcs) = self.get_pixmap_obj_funcs();
506 unsafe {
507 let ret_val = ((*funcs).scaled_to_height)(obj_data, h, enum_mode_2);
508 let t = ret_val;
509 let ret_val;
510 if t.host_data != ::std::ptr::null() {
511 ret_val = Pixmap::new_from_rc(t);
512 } else {
513 ret_val = Pixmap::new_from_owned(t);
514 }
515 ret_val
516 }
517 }
518 #[doc(hidden)]
519 pub fn to_image(&self) -> Image {
520 let (obj_data, funcs) = self.get_pixmap_obj_funcs();
521 unsafe {
522 let ret_val = ((*funcs).to_image)(obj_data);
523 let t = ret_val;
524 let ret_val;
525 if t.host_data != ::std::ptr::null() {
526 ret_val = Image::new_from_rc(t);
527 } else {
528 ret_val = Image::new_from_owned(t);
529 }
530 ret_val
531 }
532 }
533 #[doc(hidden)]
534 pub fn from_image_2<I: ImageTrait<'a>>(image: &I, flags: ImageConversionFlags) -> Pixmap<'a> {
535 let (obj_image_1, _funcs) = image.get_image_obj_funcs();
536 let enum_flags_2 = flags.bits();
537
538 let (obj_data, funcs) = unsafe {
539 (
540 ::std::ptr::null(),
541 (*((*rute_ffi_get()).get_pixmap)(::std::ptr::null()).all_funcs).pixmap_funcs,
542 )
543 };
544 unsafe {
545 let ret_val = ((*funcs).from_image_2)(obj_data, obj_image_1, enum_flags_2);
546 let t = ret_val;
547 let ret_val;
548 if t.host_data != ::std::ptr::null() {
549 ret_val = Pixmap::new_from_rc(t);
550 } else {
551 ret_val = Pixmap::new_from_owned(t);
552 }
553 ret_val
554 }
555 }
556 #[doc(hidden)]
557 pub fn convert_from_image<I: ImageTrait<'a>>(
558 &self,
559 img: &I,
560 flags: ImageConversionFlags,
561 ) -> bool {
562 let (obj_img_1, _funcs) = img.get_image_obj_funcs();
563 let enum_flags_2 = flags.bits();
564
565 let (obj_data, funcs) = self.get_pixmap_obj_funcs();
566 unsafe {
567 let ret_val = ((*funcs).convert_from_image)(obj_data, obj_img_1, enum_flags_2);
568 ret_val
569 }
570 }
571 #[doc(hidden)]
572 pub fn copy(&self, x: i32, y: i32, width: i32, height: i32) -> Pixmap {
573 let (obj_data, funcs) = self.get_pixmap_obj_funcs();
574 unsafe {
575 let ret_val = ((*funcs).copy)(obj_data, x, y, width, height);
576 let t = ret_val;
577 let ret_val;
578 if t.host_data != ::std::ptr::null() {
579 ret_val = Pixmap::new_from_rc(t);
580 } else {
581 ret_val = Pixmap::new_from_owned(t);
582 }
583 ret_val
584 }
585 }
586 #[doc(hidden)]
587 pub fn copy_2<R: RectTrait<'a>>(&self, rect: &R) -> Pixmap {
588 let (obj_rect_1, _funcs) = rect.get_rect_obj_funcs();
589
590 let (obj_data, funcs) = self.get_pixmap_obj_funcs();
591 unsafe {
592 let ret_val = ((*funcs).copy_2)(obj_data, obj_rect_1);
593 let t = ret_val;
594 let ret_val;
595 if t.host_data != ::std::ptr::null() {
596 ret_val = Pixmap::new_from_rc(t);
597 } else {
598 ret_val = Pixmap::new_from_owned(t);
599 }
600 ret_val
601 }
602 }
603 #[doc(hidden)]
604 pub fn scroll<R: RegionTrait<'a>>(
605 &self,
606 dx: i32,
607 dy: i32,
608 x: i32,
609 y: i32,
610 width: i32,
611 height: i32,
612 exposed: &R,
613 ) -> &Self {
614 let (obj_exposed_7, _funcs) = exposed.get_region_obj_funcs();
615
616 let (obj_data, funcs) = self.get_pixmap_obj_funcs();
617 unsafe {
618 ((*funcs).scroll)(obj_data, dx, dy, x, y, width, height, obj_exposed_7);
619 }
620 self
621 }
622 #[doc(hidden)]
623 pub fn scroll_2<R: RectTrait<'a>, S: RegionTrait<'a>>(
624 &self,
625 dx: i32,
626 dy: i32,
627 rect: &R,
628 exposed: &S,
629 ) -> &Self {
630 let (obj_rect_3, _funcs) = rect.get_rect_obj_funcs();
631 let (obj_exposed_4, _funcs) = exposed.get_region_obj_funcs();
632
633 let (obj_data, funcs) = self.get_pixmap_obj_funcs();
634 unsafe {
635 ((*funcs).scroll_2)(obj_data, dx, dy, obj_rect_3, obj_exposed_4);
636 }
637 self
638 }
639 #[doc(hidden)]
640 pub fn cache_key(&self) -> i64 {
641 let (obj_data, funcs) = self.get_pixmap_obj_funcs();
642 unsafe {
643 let ret_val = ((*funcs).cache_key)(obj_data);
644 ret_val
645 }
646 }
647 #[doc(hidden)]
648 pub fn is_detached(&self) -> bool {
649 let (obj_data, funcs) = self.get_pixmap_obj_funcs();
650 unsafe {
651 let ret_val = ((*funcs).is_detached)(obj_data);
652 ret_val
653 }
654 }
655 #[doc(hidden)]
656 pub fn detach(&self) -> &Self {
657 let (obj_data, funcs) = self.get_pixmap_obj_funcs();
658 unsafe {
659 ((*funcs).detach)(obj_data);
660 }
661 self
662 }
663 #[doc(hidden)]
664 pub fn is_q_bitmap(&self) -> bool {
665 let (obj_data, funcs) = self.get_pixmap_obj_funcs();
666 unsafe {
667 let ret_val = ((*funcs).is_q_bitmap)(obj_data);
668 ret_val
669 }
670 }
671 #[doc(hidden)]
672 pub fn paint_engine(&self) -> Option<PaintEngine> {
673 let (obj_data, funcs) = self.get_pixmap_obj_funcs();
674 unsafe {
675 let ret_val = ((*funcs).paint_engine)(obj_data);
676 if ret_val.qt_data == ::std::ptr::null() {
677 return None;
678 }
679 let t = ret_val;
680 let ret_val;
681 if t.host_data != ::std::ptr::null() {
682 ret_val = PaintEngine::new_from_rc(t);
683 } else {
684 ret_val = PaintEngine::new_from_owned(t);
685 }
686 Some(ret_val)
687 }
688 }
689 #[doc(hidden)]
690 pub fn painting_active(&self) -> bool {
691 let (obj_data, funcs) = self.get_paint_device_obj_funcs();
692 unsafe {
693 let ret_val = ((*funcs).painting_active)(obj_data);
694 ret_val
695 }
696 }
697 #[doc(hidden)]
698 pub fn logical_dpi_x(&self) -> i32 {
699 let (obj_data, funcs) = self.get_paint_device_obj_funcs();
700 unsafe {
701 let ret_val = ((*funcs).logical_dpi_x)(obj_data);
702 ret_val
703 }
704 }
705 #[doc(hidden)]
706 pub fn logical_dpi_y(&self) -> i32 {
707 let (obj_data, funcs) = self.get_paint_device_obj_funcs();
708 unsafe {
709 let ret_val = ((*funcs).logical_dpi_y)(obj_data);
710 ret_val
711 }
712 }
713 #[doc(hidden)]
714 pub fn physical_dpi_x(&self) -> i32 {
715 let (obj_data, funcs) = self.get_paint_device_obj_funcs();
716 unsafe {
717 let ret_val = ((*funcs).physical_dpi_x)(obj_data);
718 ret_val
719 }
720 }
721 #[doc(hidden)]
722 pub fn physical_dpi_y(&self) -> i32 {
723 let (obj_data, funcs) = self.get_paint_device_obj_funcs();
724 unsafe {
725 let ret_val = ((*funcs).physical_dpi_y)(obj_data);
726 ret_val
727 }
728 }
729 #[doc(hidden)]
730 pub fn device_pixel_ratio_f(&self) -> f32 {
731 let (obj_data, funcs) = self.get_paint_device_obj_funcs();
732 unsafe {
733 let ret_val = ((*funcs).device_pixel_ratio_f)(obj_data);
734 ret_val
735 }
736 }
737 #[doc(hidden)]
738 pub fn color_count(&self) -> i32 {
739 let (obj_data, funcs) = self.get_paint_device_obj_funcs();
740 unsafe {
741 let ret_val = ((*funcs).color_count)(obj_data);
742 ret_val
743 }
744 }
745
746 pub fn build(&self) -> Self {
747 self.clone()
748 }
749}
750pub trait BitmapTrait<'a> {
751 #[inline]
752 #[doc(hidden)]
753 fn get_bitmap_obj_funcs(&self) -> (*const RUBase, *const RUBitmapFuncs);
754}
755
756impl<'a> PaintDeviceTrait<'a> for Bitmap<'a> {
757 #[doc(hidden)]
758 fn get_paint_device_obj_funcs(&self) -> (*const RUBase, *const RUPaintDeviceFuncs) {
759 let obj = self.data.get().unwrap();
760 unsafe { (obj, (*self.all_funcs).paint_device_funcs) }
761 }
762}
763
764impl<'a> PixmapTrait<'a> for Bitmap<'a> {
765 #[doc(hidden)]
766 fn get_pixmap_obj_funcs(&self) -> (*const RUBase, *const RUPixmapFuncs) {
767 let obj = self.data.get().unwrap();
768 unsafe { (obj, (*self.all_funcs).pixmap_funcs) }
769 }
770}
771
772impl<'a> BitmapTrait<'a> for Bitmap<'a> {
773 #[doc(hidden)]
774 fn get_bitmap_obj_funcs(&self) -> (*const RUBase, *const RUBitmapFuncs) {
775 let obj = self.data.get().unwrap();
776 unsafe { (obj, (*self.all_funcs).bitmap_funcs) }
777 }
778}