Struct gdk_pixbuf::Pixbuf

#[repr(transparent)]
pub struct Pixbuf { /* private fields */ }

Implementations

impl Pixbuf

pub fn new(
    colorspace: Colorspace,
    has_alpha: bool,
    bits_per_sample: i32,
    width: i32,
    height: i32
) -> Option<Pixbuf>

pub fn from_bytes(
    data: &Bytes,
    colorspace: Colorspace,
    has_alpha: bool,
    bits_per_sample: i32,
    width: i32,
    height: i32,
    rowstride: i32
) -> Pixbuf

pub fn from_resource(resource_path: &str) -> Result<Pixbuf, Error>

pub fn from_resource_at_scale(
    resource_path: &str,
    width: i32,
    height: i32,
    preserve_aspect_ratio: bool
) -> Result<Pixbuf, Error>

pub fn from_stream(
    stream: &impl IsA<InputStream>,
    cancellable: Option<&impl IsA<Cancellable>>
) -> Result<Pixbuf, Error>

pub fn from_stream_at_scale(
    stream: &impl IsA<InputStream>,
    width: i32,
    height: i32,
    preserve_aspect_ratio: bool,
    cancellable: Option<&impl IsA<Cancellable>>
) -> Result<Pixbuf, Error>

pub fn from_xpm_data(data: &[&str]) -> Pixbuf

pub fn add_alpha(
    &self,
    substitute_color: bool,
    r: u8,
    g: u8,
    b: u8
) -> Option<Pixbuf>

pub fn apply_embedded_orientation(&self) -> Option<Pixbuf>

pub fn composite(
    &self,
    dest: &Pixbuf,
    dest_x: i32,
    dest_y: i32,
    dest_width: i32,
    dest_height: i32,
    offset_x: f64,
    offset_y: f64,
    scale_x: f64,
    scale_y: f64,
    interp_type: InterpType,
    overall_alpha: i32
)

pub fn composite_color(
    &self,
    dest: &Pixbuf,
    dest_x: i32,
    dest_y: i32,
    dest_width: i32,
    dest_height: i32,
    offset_x: f64,
    offset_y: f64,
    scale_x: f64,
    scale_y: f64,
    interp_type: InterpType,
    overall_alpha: i32,
    check_x: i32,
    check_y: i32,
    check_size: i32,
    color1: u32,
    color2: u32
)

pub fn composite_color_simple(
    &self,
    dest_width: i32,
    dest_height: i32,
    interp_type: InterpType,
    overall_alpha: i32,
    check_size: i32,
    color1: u32,
    color2: u32
) -> Option<Pixbuf>

pub fn copy(&self) -> Option<Pixbuf>

pub fn copy_area(
    &self,
    src_x: i32,
    src_y: i32,
    width: i32,
    height: i32,
    dest_pixbuf: &Pixbuf,
    dest_x: i32,
    dest_y: i32
)

pub fn copy_options(&self, dest_pixbuf: &Pixbuf) -> bool

pub fn fill(&self, pixel: u32)

pub fn flip(&self, horizontal: bool) -> Option<Pixbuf>

pub fn bits_per_sample(&self) -> i32

pub fn byte_length(&self) -> usize

pub fn colorspace(&self) -> Colorspace

pub fn has_alpha(&self) -> bool

pub fn height(&self) -> i32

pub fn n_channels(&self) -> i32

pub fn option(&self, key: &str) -> Option<GString>

pub fn rowstride(&self) -> i32

pub fn width(&self) -> i32

pub fn new_subpixbuf(
    &self,
    src_x: i32,
    src_y: i32,
    width: i32,
    height: i32
) -> Option<Pixbuf>

pub fn read_pixel_bytes(&self) -> Option<Bytes>

pub fn remove_option(&self, key: &str) -> bool

pub fn rotate_simple(&self, angle: PixbufRotation) -> Option<Pixbuf>

pub fn saturate_and_pixelate(&self, dest: &Pixbuf, saturation: f32, pixelate: bool)

pub fn scale(
    &self,
    dest: &Pixbuf,
    dest_x: i32,
    dest_y: i32,
    dest_width: i32,
    dest_height: i32,
    offset_x: f64,
    offset_y: f64,
    scale_x: f64,
    scale_y: f64,
    interp_type: InterpType
)

pub fn scale_simple(
    &self,
    dest_width: i32,
    dest_height: i32,
    interp_type: InterpType
) -> Option<Pixbuf>

pub fn set_option(&self, key: &str, value: &str) -> bool

pub fn pixel_bytes(&self) -> Option<Bytes>

pub fn calculate_rowstride(
    colorspace: Colorspace,
    has_alpha: bool,
    bits_per_sample: i32,
    width: i32,
    height: i32
) -> i32

pub fn formats() -> Vec<PixbufFormat>

pub fn init_modules(path: &str) -> Result<(), Error>

Available on crate feature v2_40 only.

impl Pixbuf

pub fn from_mut_slice<T: AsMut<[u8]>>(
    data: T,
    colorspace: Colorspace,
    has_alpha: bool,
    bits_per_sample: i32,
    width: i32,
    height: i32,
    row_stride: i32
) -> Pixbuf

pub fn from_read<R: Read + Send + 'static>(r: R) -> Result<Pixbuf, Error>

Creates a Pixbuf from a type implementing Read (like File).

use std::fs::File;
use gdk_pixbuf::Pixbuf;

let f = File::open("some_file.png").expect("failed to open image");
let pixbuf = Pixbuf::from_read(f).expect("failed to load image");

pub fn from_file<T: AsRef<Path>>(filename: T) -> Result<Pixbuf, Error>

pub fn from_file_at_size<T: AsRef<Path>>(
    filename: T,
    width: i32,
    height: i32
) -> Result<Pixbuf, Error>

pub fn from_file_at_scale<T: AsRef<Path>>(
    filename: T,
    width: i32,
    height: i32,
    preserve_aspect_ratio: bool
) -> Result<Pixbuf, Error>

pub fn from_stream_async<P: IsA<InputStream>, Q: IsA<Cancellable>, R: FnOnce(Result<Pixbuf, Error>) + 'static>(
    stream: &P,
    cancellable: Option<&Q>,
    callback: R
)

pub fn from_stream_future<P: IsA<InputStream> + Clone + 'static>(
    stream: &P
) -> Pin<Box<dyn Future<Output = Result<Pixbuf, Error>> + 'static>>

pub fn from_stream_at_scale_async<P: IsA<InputStream>, Q: IsA<Cancellable>, R: FnOnce(Result<Pixbuf, Error>) + 'static>(
    stream: &P,
    width: i32,
    height: i32,
    preserve_aspect_ratio: bool,
    cancellable: Option<&Q>,
    callback: R
)

pub fn from_stream_at_scale_future<P: IsA<InputStream> + Clone + 'static>(
    stream: &P,
    width: i32,
    height: i32,
    preserve_aspect_ratio: bool
) -> Pin<Box<dyn Future<Output = Result<Pixbuf, Error>> + 'static>>

pub unsafe fn pixels(&self) -> &mut [u8]

Returns a mutable slice to the pixbuf’s pixel data.

This function will cause an implicit copy if the pixbuf was created from read-only data.

Please see the section on image data for information about how the pixel data is stored in memory.

Safety

No other reference to this pixbuf’s data must exist when this method is called.

Until you drop the returned reference, you must not call any methods on the pixbuf which may read or write to the data.

pub fn put_pixel(&self, x: u32, y: u32, red: u8, green: u8, blue: u8, alpha: u8)

pub fn file_info<T: AsRef<Path>>(
    filename: T
) -> Option<(PixbufFormat, i32, i32)>

pub fn file_info_async<P: IsA<Cancellable>, Q: FnOnce(Result<Option<(PixbufFormat, i32, i32)>, Error>) + 'static, T: AsRef<Path>>(
    filename: T,
    cancellable: Option<&P>,
    callback: Q
)

pub fn file_info_future<T: AsRef<Path> + Clone + 'static>(
    filename: T
) -> Pin<Box<dyn Future<Output = Result<Option<(PixbufFormat, i32, i32)>, Error>> + 'static>>

pub fn save_to_bufferv(
    &self,
    type_: &str,
    options: &[(&str, &str)]
) -> Result<Vec<u8>, Error>

pub fn save_to_streamv<P: IsA<OutputStream>, Q: IsA<Cancellable>>(
    &self,
    stream: &P,
    type_: &str,
    options: &[(&str, &str)],
    cancellable: Option<&Q>
) -> Result<(), Error>

pub fn save_to_streamv_async<P: IsA<OutputStream>, Q: IsA<Cancellable>, R: FnOnce(Result<(), Error>) + 'static>(
    &self,
    stream: &P,
    type_: &str,
    options: &[(&str, &str)],
    cancellable: Option<&Q>,
    callback: R
)

pub fn save_to_streamv_future<P: IsA<OutputStream> + Clone + 'static>(
    &self,
    stream: &P,
    type_: &str,
    options: &[(&str, &str)]
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'static>>

pub fn savev<T: AsRef<Path>>(
    &self,
    filename: T,
    type_: &str,
    options: &[(&str, &str)]
) -> Result<(), Error>

Trait Implementations

impl Clone for Pixbuf

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Pixbuf

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for Pixbuf

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for Pixbuf

fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl Ord for Pixbuf

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self where
    Self: PartialOrd<Self>, 

Restrict a value to a certain interval.

impl ParentClassIs for Pixbuf

type Parent = Object

impl<OT: ObjectType> PartialEq<OT> for Pixbuf

fn eq(&self, other: &OT) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<OT: ObjectType> PartialOrd<OT> for Pixbuf

fn partial_cmp(&self, other: &OT) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl StaticType for Pixbuf

fn static_type() -> Type

Returns the type identifier of Self.

impl Eq for Pixbuf

impl IsA<Icon> for Pixbuf

impl IsA<LoadableIcon> for Pixbuf