Struct IconFamily

pub struct IconFamily {
    pub elements: Vec<IconElement>,
}

A set of icons stored in a single ICNS file.

Fields

elements: Vec<IconElement>

The icon elements stored in the ICNS file.

Implementations

impl IconFamily

pub fn new() -> IconFamily

Creates a new, empty icon family.

Examples found in repository

examples/png2icns.rs (line 44)

fn main() {
    let num_args = env::args().count();
    if num_args < 2 || num_args > 3 {
        println!("Usage: png2icns <path> [<ostype>]");
        return;
    }
    let png_path = env::args().nth(1).unwrap();
    let png_path = Path::new(&png_path);
    let png_file = BufReader::new(File::open(png_path).expect("failed to open PNG file"));
    let image = Image::read_png(png_file).expect("failed to read PNG file");
    let mut family = IconFamily::new();
    let icns_path = if num_args == 3 {
        let ostype = OSType::from_str(&env::args().nth(2).unwrap()).unwrap();
        let icon_type = IconType::from_ostype(ostype).expect("unsupported ostype");
        family
            .add_icon_with_type(&image, icon_type)
            .expect("failed to encode image");
        png_path.with_extension(format!("{}.icns", ostype))
    } else {
        family.add_icon(&image).expect("failed to encode image");
        png_path.with_extension("icns")
    };
    let icns_file = BufWriter::new(File::create(icns_path).expect("failed to create ICNS file"));
    family.write(icns_file).expect("failed to write ICNS file");
}

pub fn is_empty(&self) -> bool

Returns true if the icon family contains no icons nor any other elements.

pub fn add_icon(&mut self, image: &Image) -> Result<()>

Encodes the image into the family, automatically choosing an appropriate icon type based on the dimensions of the image. Returns an error if there is no supported icon type matching the image dimensions.

Examples found in repository

examples/png2icns.rs (line 53)

fn main() {
    let num_args = env::args().count();
    if num_args < 2 || num_args > 3 {
        println!("Usage: png2icns <path> [<ostype>]");
        return;
    }
    let png_path = env::args().nth(1).unwrap();
    let png_path = Path::new(&png_path);
    let png_file = BufReader::new(File::open(png_path).expect("failed to open PNG file"));
    let image = Image::read_png(png_file).expect("failed to read PNG file");
    let mut family = IconFamily::new();
    let icns_path = if num_args == 3 {
        let ostype = OSType::from_str(&env::args().nth(2).unwrap()).unwrap();
        let icon_type = IconType::from_ostype(ostype).expect("unsupported ostype");
        family
            .add_icon_with_type(&image, icon_type)
            .expect("failed to encode image");
        png_path.with_extension(format!("{}.icns", ostype))
    } else {
        family.add_icon(&image).expect("failed to encode image");
        png_path.with_extension("icns")
    };
    let icns_file = BufWriter::new(File::create(icns_path).expect("failed to create ICNS file"));
    family.write(icns_file).expect("failed to write ICNS file");
}

pub fn add_icon_with_type( &mut self, image: &Image, icon_type: IconType, ) -> Result<()>

Encodes the image into the family using the given icon type. If the selected type has an associated mask type, the image mask will also be added to the family. Returns an error if the image has the wrong dimensions for the selected type.

Examples found in repository

examples/png2icns.rs (line 49)

fn main() {
    let num_args = env::args().count();
    if num_args < 2 || num_args > 3 {
        println!("Usage: png2icns <path> [<ostype>]");
        return;
    }
    let png_path = env::args().nth(1).unwrap();
    let png_path = Path::new(&png_path);
    let png_file = BufReader::new(File::open(png_path).expect("failed to open PNG file"));
    let image = Image::read_png(png_file).expect("failed to read PNG file");
    let mut family = IconFamily::new();
    let icns_path = if num_args == 3 {
        let ostype = OSType::from_str(&env::args().nth(2).unwrap()).unwrap();
        let icon_type = IconType::from_ostype(ostype).expect("unsupported ostype");
        family
            .add_icon_with_type(&image, icon_type)
            .expect("failed to encode image");
        png_path.with_extension(format!("{}.icns", ostype))
    } else {
        family.add_icon(&image).expect("failed to encode image");
        png_path.with_extension("icns")
    };
    let icns_file = BufWriter::new(File::create(icns_path).expect("failed to create ICNS file"));
    family.write(icns_file).expect("failed to write ICNS file");
}

pub fn available_icons(&self) -> Vec<IconType>

Returns a list of all (non-mask) icon types for which the icon family contains the necessary element(s) for a complete icon image (including alpha channel). These icon types can be passed to the get_icon_with_type method to decode the icons.

Examples found in repository

examples/icns2png.rs (line 49)

fn main() {
    let num_args = env::args().count();
    if num_args < 2 || num_args > 3 {
        println!("Usage: icns2png <path> [<ostype>]");
        return;
    }
    let icns_path = env::args().nth(1).unwrap();
    let icns_path = Path::new(&icns_path);
    let icns_file = BufReader::new(File::open(icns_path).expect("failed to open ICNS file"));
    let family = IconFamily::read(icns_file).expect("failed to read ICNS file");
    let (icon_type, png_path) = if num_args == 3 {
        let ostype = OSType::from_str(&env::args().nth(2).unwrap()).unwrap();
        let icon_type = IconType::from_ostype(ostype).expect("unsupported ostype");
        let png_path = icns_path.with_extension(format!("{}.png", ostype));
        (icon_type, png_path)
    } else {
        // If no OSType is specified, extract the highest-resolution icon.
        let &icon_type = family
            .available_icons()
            .iter()
            .max_by_key(|icon_type| icon_type.pixel_width() * icon_type.pixel_height())
            .expect("ICNS file contains no icons");
        let png_path = icns_path.with_extension("png");
        (icon_type, png_path)
    };
    let image = family
        .get_icon_with_type(icon_type)
        .expect("ICNS file does not contain that icon type");
    let png_file = BufWriter::new(File::create(png_path).expect("failed to create PNG file"));
    image.write_png(png_file).expect("failed to write PNG file");
}

pub fn has_icon_with_type(&self, icon_type: IconType) -> bool

Determines whether the icon family contains a complete icon with the given type (including the mask, if the given icon type has an associated mask type).

pub fn get_icon_with_type(&self, icon_type: IconType) -> Result<Image>

Decodes an image from the family with the given icon type. If the selected type has an associated mask type, the two elements will decoded together into a single image. Returns an error if the element(s) for the selected type are not present in the icon family, or the if the encoded data is malformed.

Examples found in repository

examples/icns2png.rs (line 57)

fn main() {
    let num_args = env::args().count();
    if num_args < 2 || num_args > 3 {
        println!("Usage: icns2png <path> [<ostype>]");
        return;
    }
    let icns_path = env::args().nth(1).unwrap();
    let icns_path = Path::new(&icns_path);
    let icns_file = BufReader::new(File::open(icns_path).expect("failed to open ICNS file"));
    let family = IconFamily::read(icns_file).expect("failed to read ICNS file");
    let (icon_type, png_path) = if num_args == 3 {
        let ostype = OSType::from_str(&env::args().nth(2).unwrap()).unwrap();
        let icon_type = IconType::from_ostype(ostype).expect("unsupported ostype");
        let png_path = icns_path.with_extension(format!("{}.png", ostype));
        (icon_type, png_path)
    } else {
        // If no OSType is specified, extract the highest-resolution icon.
        let &icon_type = family
            .available_icons()
            .iter()
            .max_by_key(|icon_type| icon_type.pixel_width() * icon_type.pixel_height())
            .expect("ICNS file contains no icons");
        let png_path = icns_path.with_extension("png");
        (icon_type, png_path)
    };
    let image = family
        .get_icon_with_type(icon_type)
        .expect("ICNS file does not contain that icon type");
    let png_file = BufWriter::new(File::create(png_path).expect("failed to create PNG file"));
    image.write_png(png_file).expect("failed to write PNG file");
}

pub fn read<R: Read>(reader: R) -> Result<IconFamily>

Reads an icon family from an ICNS file.

Examples found in repository

examples/readicns.rs (line 16)

fn main() {
    if env::args().count() != 2 {
        println!("Usage: readicns <path>");
        return;
    }
    let path = env::args().nth(1).unwrap();
    let file = File::open(path).expect("failed to open file");
    let buffered = BufReader::new(file);
    let family = IconFamily::read(buffered).expect("failed to read ICNS file");
    println!("ICNS file contains {} element(s).", family.elements.len());
    for (index, element) in family.elements.iter().enumerate() {
        println!(
            "Element {}: {} ({} byte payload)",
            index,
            element.ostype,
            element.data.len()
        );
    }
}

examples/icns2png.rs (line 40)

fn main() {
    let num_args = env::args().count();
    if num_args < 2 || num_args > 3 {
        println!("Usage: icns2png <path> [<ostype>]");
        return;
    }
    let icns_path = env::args().nth(1).unwrap();
    let icns_path = Path::new(&icns_path);
    let icns_file = BufReader::new(File::open(icns_path).expect("failed to open ICNS file"));
    let family = IconFamily::read(icns_file).expect("failed to read ICNS file");
    let (icon_type, png_path) = if num_args == 3 {
        let ostype = OSType::from_str(&env::args().nth(2).unwrap()).unwrap();
        let icon_type = IconType::from_ostype(ostype).expect("unsupported ostype");
        let png_path = icns_path.with_extension(format!("{}.png", ostype));
        (icon_type, png_path)
    } else {
        // If no OSType is specified, extract the highest-resolution icon.
        let &icon_type = family
            .available_icons()
            .iter()
            .max_by_key(|icon_type| icon_type.pixel_width() * icon_type.pixel_height())
            .expect("ICNS file contains no icons");
        let png_path = icns_path.with_extension("png");
        (icon_type, png_path)
    };
    let image = family
        .get_icon_with_type(icon_type)
        .expect("ICNS file does not contain that icon type");
    let png_file = BufWriter::new(File::create(png_path).expect("failed to create PNG file"));
    image.write_png(png_file).expect("failed to write PNG file");
}

pub fn write<W: Write>(&self, writer: W) -> Result<()>

Writes the icon family to an ICNS file.

Examples found in repository

examples/png2icns.rs (line 57)

fn main() {
    let num_args = env::args().count();
    if num_args < 2 || num_args > 3 {
        println!("Usage: png2icns <path> [<ostype>]");
        return;
    }
    let png_path = env::args().nth(1).unwrap();
    let png_path = Path::new(&png_path);
    let png_file = BufReader::new(File::open(png_path).expect("failed to open PNG file"));
    let image = Image::read_png(png_file).expect("failed to read PNG file");
    let mut family = IconFamily::new();
    let icns_path = if num_args == 3 {
        let ostype = OSType::from_str(&env::args().nth(2).unwrap()).unwrap();
        let icon_type = IconType::from_ostype(ostype).expect("unsupported ostype");
        family
            .add_icon_with_type(&image, icon_type)
            .expect("failed to encode image");
        png_path.with_extension(format!("{}.icns", ostype))
    } else {
        family.add_icon(&image).expect("failed to encode image");
        png_path.with_extension("icns")
    };
    let icns_file = BufWriter::new(File::create(icns_path).expect("failed to create ICNS file"));
    family.write(icns_file).expect("failed to write ICNS file");
}

pub fn total_length(&self) -> u32

Returns the encoded length of the file, in bytes, including the length of the header.