1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189
#![allow( clippy::too_many_arguments, clippy::let_and_return, clippy::from_over_into )] use crate::{Context, Object, TexturePixmapX11ReportLevel}; use glib::translate::*; use std::{fmt, ptr}; glib_wrapper! { pub struct TexturePixmapX11(Object<ffi::CoglTexturePixmapX11, TexturePixmapX11Class>) @extends Object; match fn { get_type => || ffi::cogl_texture_pixmap_x11_get_gtype(), } } impl TexturePixmapX11 { /// Creates a texture that contains the contents of `pixmap`. If /// `automatic_updates` is `true` then Cogl will attempt to listen for /// damage events on the pixmap and automatically update the texture /// when it changes. /// ## `context` /// A `Context` /// ## `pixmap` /// A X11 pixmap ID /// ## `automatic_updates` /// Whether to automatically copy the contents of /// the pixmap to the texture. /// /// # Returns /// /// a new `TexturePixmapX11` instance pub fn new( context: &Context, pixmap: u32, automatic_updates: bool, ) -> Result<TexturePixmapX11, glib::Error> { unsafe { let mut error = ptr::null_mut(); let ret = ffi::cogl_texture_pixmap_x11_new( context.to_glib_none().0, pixmap, automatic_updates as i32, &mut error, ); if error.is_null() { Ok(from_glib_full(ret)) } else { Err(from_glib_full(error)) } } } /// Creates one of a pair of textures to contain the contents of `pixmap`, /// which has stereo content. (Different images for the right and left eyes.) /// The left image is drawn using this texture; the right image is drawn /// using a texture created by calling /// `TexturePixmapX11::new_right` and passing in this texture as an /// argument. /// /// In general, you should not use this function unless you have /// queried the `GLX_STEREO_TREE_EXT` attribute of the corresponding /// window using glXQueryDrawable() and determined that the window is /// stereo. Note that this attribute can change over time and /// notification is also provided through events defined in the /// EXT_stereo_tree GLX extension. As long as the system has support for /// stereo content, drawing using the left and right pixmaps will not /// produce an error even if the window doesn't have stereo /// content any more, but drawing with the right pixmap will produce /// undefined output, so you need to listen for these events and /// re-render to avoid race conditions. (Recreating a non-stereo /// pixmap is not necessary, but may save resources.) /// ## `context` /// A `Context` /// ## `pixmap` /// A X11 pixmap ID /// ## `automatic_updates` /// Whether to automatically copy the contents of /// the pixmap to the texture. /// /// # Returns /// /// a new `TexturePixmapX11` instance pub fn new_left( context: &Context, pixmap: u32, automatic_updates: bool, ) -> Result<TexturePixmapX11, glib::Error> { unsafe { let mut error = ptr::null_mut(); let ret = ffi::cogl_texture_pixmap_x11_new_left( context.to_glib_none().0, pixmap, automatic_updates as i32, &mut error, ); if error.is_null() { Ok(from_glib_full(ret)) } else { Err(from_glib_full(error)) } } } /// Checks whether the given `self` is using the /// GLX_EXT_texture_from_pixmap or similar extension to copy the /// contents of the pixmap to the texture. This extension is usually /// implemented as zero-copy operation so it implies the updates are /// working efficiently. /// /// # Returns /// /// `true` if the texture is using an efficient extension /// and `false` otherwise pub fn is_using_tfp_extension(&self) -> bool { unsafe { ffi::cogl_texture_pixmap_x11_is_using_tfp_extension(self.to_glib_none().0) == crate::TRUE } } /// Creates a texture object that corresponds to the right-eye image /// of a pixmap with stereo content. `self` must have been /// created using `TexturePixmapX11::new_left`. /// /// # Returns /// /// a new `TexturePixmapX11` instance pub fn new_right(&self) -> Option<TexturePixmapX11> { unsafe { from_glib_none(ffi::cogl_texture_pixmap_x11_new_right( self.to_glib_none().0, )) } } /// Sets the damage object that will be used to track automatic updates /// to the `self`. Damage tracking can be disabled by passing 0 for /// `damage`. Otherwise this damage will replace the one used if `true` /// was passed for automatic_updates to `TexturePixmapX11::new`. /// /// Note that Cogl will subtract from the damage region as it processes /// damage events. /// ## `damage` /// A X11 Damage object or 0 /// ## `report_level` /// The report level which describes how to interpret /// the damage events. This should match the level that the damage /// object was created with. pub fn set_damage_object(&self, damage: u32, report_level: TexturePixmapX11ReportLevel) { unsafe { ffi::cogl_texture_pixmap_x11_set_damage_object( self.to_glib_none().0, damage, report_level.to_glib(), ); } } /// Forces an update of the given `self` so that it is refreshed with /// the contents of the pixmap that was given to /// `TexturePixmapX11::new`. /// ## `x` /// x coordinate of the area to update /// ## `y` /// y coordinate of the area to update /// ## `width` /// width of the area to update /// ## `height` /// height of the area to update pub fn update_area(&self, x: i32, y: i32, width: i32, height: i32) { unsafe { ffi::cogl_texture_pixmap_x11_update_area(self.to_glib_none().0, x, y, width, height); } } pub fn error_quark() -> u32 { unsafe { ffi::cogl_texture_pixmap_x11_error_quark() } } } impl fmt::Display for TexturePixmapX11 { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "TexturePixmapX11") } }