Deleted vendor folder

4 files changed, 0 insertions, 832 deletions

diff --git a/vendor/png/examples/corpus-bench.rs b/vendor/png/examples/corpus-bench.rs
deleted file mode 100644
index b030d6d..0000000
--- a/vendor/png/examples/corpus-bench.rs
+++ /dev/null
@@ -1,198 +0,0 @@
-use std::{fs, path::PathBuf};
-
-use clap::Parser;
-use png::Decoder;
-
-#[derive(clap::ValueEnum, Clone)]
-enum Speed {
-    Fast,
-    Default,
-    Best,
-}
-
-#[derive(clap::ValueEnum, Clone)]
-enum Filter {
-    None,
-    Sub,
-    Up,
-    Average,
-    Paeth,
-    Adaptive,
-}
-
-#[derive(clap::Parser)]
-struct Args {
-    directory: Option<PathBuf>,
-    #[clap(short, long, value_enum, default_value_t = Speed::Fast)]
-    speed: Speed,
-    #[clap(short, long, value_enum, default_value_t = Filter::Adaptive)]
-    filter: Filter,
-}
-
-#[inline(never)]
-fn run_encode(
-    args: &Args,
-    dimensions: (u32, u32),
-    color_type: png::ColorType,
-    bit_depth: png::BitDepth,
-    image: &[u8],
-) -> Vec<u8> {
-    let mut reencoded = Vec::new();
-    let mut encoder = png::Encoder::new(&mut reencoded, dimensions.0, dimensions.1);
-    encoder.set_color(color_type);
-    encoder.set_depth(bit_depth);
-    encoder.set_compression(match args.speed {
-        Speed::Fast => png::Compression::Fast,
-        Speed::Default => png::Compression::Default,
-        Speed::Best => png::Compression::Best,
-    });
-    encoder.set_filter(match args.filter {
-        Filter::None => png::FilterType::NoFilter,
-        Filter::Sub => png::FilterType::Sub,
-        Filter::Up => png::FilterType::Up,
-        Filter::Average => png::FilterType::Avg,
-        Filter::Paeth => png::FilterType::Paeth,
-        Filter::Adaptive => png::FilterType::Paeth,
-    });
-    encoder.set_adaptive_filter(match args.filter {
-        Filter::Adaptive => png::AdaptiveFilterType::Adaptive,
-        _ => png::AdaptiveFilterType::NonAdaptive,
-    });
-    let mut encoder = encoder.write_header().unwrap();
-    encoder.write_image_data(&image).unwrap();
-    encoder.finish().unwrap();
-    reencoded
-}
-
-#[inline(never)]
-fn run_decode(image: &[u8], output: &mut [u8]) {
-    let mut reader = Decoder::new(image).read_info().unwrap();
-    reader.next_frame(output).unwrap();
-}
-
-fn main() {
-    let mut total_uncompressed = 0;
-    let mut total_compressed = 0;
-    let mut total_pixels = 0;
-    let mut total_encode_time = 0;
-    let mut total_decode_time = 0;
-
-    let args = Args::parse();
-
-    println!(
-        "{:45} Ratio             Encode                    Decode",
-        "Directory"
-    );
-    println!(
-        "{:45}-------     --------------------      --------------------",
-        "---------"
-    );
-
-    let mut image2 = Vec::new();
-
-    let mut pending = vec![args.directory.clone().unwrap_or(PathBuf::from("."))];
-    while let Some(directory) = pending.pop() {
-        let mut dir_uncompressed = 0;
-        let mut dir_compressed = 0;
-        let mut dir_pixels = 0;
-        let mut dir_encode_time = 0;
-        let mut dir_decode_time = 0;
-
-        for entry in fs::read_dir(&directory).unwrap().flatten() {
-            if entry.file_type().unwrap().is_dir() {
-                pending.push(entry.path());
-                continue;
-            }
-
-            match entry.path().extension() {
-                Some(st) if st == "png" => {}
-                _ => continue,
-            }
-
-            // Parse
-            let data = fs::read(entry.path()).unwrap();
-            let mut decoder = Decoder::new(&*data);
-            if decoder.read_header_info().ok().map(|h| h.color_type)
-                == Some(png::ColorType::Indexed)
-            {
-                decoder.set_transformations(
-                    png::Transformations::EXPAND | png::Transformations::STRIP_16,
-                );
-            }
-            let mut reader = match decoder.read_info() {
-                Ok(reader) => reader,
-                Err(_) => continue,
-            };
-            let mut image = vec![0; reader.output_buffer_size()];
-            let info = match reader.next_frame(&mut image) {
-                Ok(info) => info,
-                Err(_) => continue,
-            };
-            let (width, height) = (info.width, info.height);
-            let bit_depth = info.bit_depth;
-            let mut color_type = info.color_type;
-
-            // qoibench expands grayscale to RGB, so we do the same.
-            if bit_depth == png::BitDepth::Eight {
-                if color_type == png::ColorType::Grayscale {
-                    image = image.into_iter().flat_map(|v| [v, v, v, 255]).collect();
-                    color_type = png::ColorType::Rgba;
-                } else if color_type == png::ColorType::GrayscaleAlpha {
-                    image = image
-                        .chunks_exact(2)
-                        .flat_map(|v| [v[0], v[0], v[0], v[1]])
-                        .collect();
-                    color_type = png::ColorType::Rgba;
-                }
-            }
-
-            // Re-encode
-            let start = std::time::Instant::now();
-            let reencoded = run_encode(&args, (width, height), color_type, bit_depth, &image);
-            let elapsed = start.elapsed().as_nanos() as u64;
-
-            // And decode again
-            image2.resize(image.len(), 0);
-            let start2 = std::time::Instant::now();
-            run_decode(&reencoded, &mut image2);
-            let elapsed2 = start2.elapsed().as_nanos() as u64;
-
-            assert_eq!(image, image2);
-
-            // Stats
-            dir_uncompressed += image.len();
-            dir_compressed += reencoded.len();
-            dir_pixels += (width * height) as u64;
-            dir_encode_time += elapsed;
-            dir_decode_time += elapsed2;
-        }
-        if dir_uncompressed > 0 {
-            println!(
-                "{:45}{:6.2}%{:8} mps {:6.2} GiB/s {:8} mps {:6.2} GiB/s",
-                directory.display(),
-                100.0 * dir_compressed as f64 / dir_uncompressed as f64,
-                dir_pixels * 1000 / dir_encode_time,
-                dir_uncompressed as f64 / (dir_encode_time as f64 * 1e-9 * (1 << 30) as f64),
-                dir_pixels * 1000 / dir_decode_time,
-                dir_uncompressed as f64 / (dir_decode_time as f64 * 1e-9 * (1 << 30) as f64)
-            );
-        }
-
-        total_uncompressed += dir_uncompressed;
-        total_compressed += dir_compressed;
-        total_pixels += dir_pixels;
-        total_encode_time += dir_encode_time;
-        total_decode_time += dir_decode_time;
-    }
-
-    println!();
-    println!(
-        "{:44}{:7.3}%{:8} mps {:6.3} GiB/s {:8} mps {:6.3} GiB/s",
-        "Total",
-        100.0 * total_compressed as f64 / total_uncompressed as f64,
-        total_pixels * 1000 / total_encode_time,
-        total_uncompressed as f64 / (total_encode_time as f64 * 1e-9 * (1 << 30) as f64),
-        total_pixels * 1000 / total_decode_time,
-        total_uncompressed as f64 / (total_decode_time as f64 * 1e-9 * (1 << 30) as f64)
-    );
-}
diff --git a/vendor/png/examples/png-generate.rs b/vendor/png/examples/png-generate.rs
deleted file mode 100644
index 9036a04..0000000
--- a/vendor/png/examples/png-generate.rs
+++ /dev/null
@@ -1,55 +0,0 @@
-// For reading and opening files
-use png::text_metadata::{ITXtChunk, ZTXtChunk};
-use std::env;
-use std::fs::File;
-use std::io::BufWriter;
-
-fn main() {
-    let path = env::args()
-        .nth(1)
-        .expect("Expected a filename to output to.");
-    let file = File::create(path).unwrap();
-    let w = &mut BufWriter::new(file);
-
-    let mut encoder = png::Encoder::new(w, 2, 1); // Width is 2 pixels and height is 1.
-    encoder.set_color(png::ColorType::Rgba);
-    encoder.set_depth(png::BitDepth::Eight);
-    // Adding text chunks to the header
-    encoder
-        .add_text_chunk(
-            "Testing tEXt".to_string(),
-            "This is a tEXt chunk that will appear before the IDAT chunks.".to_string(),
-        )
-        .unwrap();
-    encoder
-        .add_ztxt_chunk(
-            "Testing zTXt".to_string(),
-            "This is a zTXt chunk that is compressed in the png file.".to_string(),
-        )
-        .unwrap();
-    encoder
-        .add_itxt_chunk(
-            "Testing iTXt".to_string(),
-            "iTXt chunks support all of UTF8. Example: हिंदी.".to_string(),
-        )
-        .unwrap();
-
-    let mut writer = encoder.write_header().unwrap();
-
-    let data = [255, 0, 0, 255, 0, 0, 0, 255]; // An array containing a RGBA sequence. First pixel is red and second pixel is black.
-    writer.write_image_data(&data).unwrap(); // Save
-
-    // We can add a tEXt/zTXt/iTXt at any point before the encoder is dropped from scope. These chunks will be at the end of the png file.
-    let tail_ztxt_chunk = ZTXtChunk::new(
-        "Comment".to_string(),
-        "A zTXt chunk after the image data.".to_string(),
-    );
-    writer.write_text_chunk(&tail_ztxt_chunk).unwrap();
-
-    // The fields of the text chunk are public, so they can be mutated before being written to the file.
-    let mut tail_itxt_chunk = ITXtChunk::new("Author".to_string(), "सायंतन खान".to_string());
-    tail_itxt_chunk.compressed = true;
-    tail_itxt_chunk.language_tag = "hi".to_string();
-    tail_itxt_chunk.translated_keyword = "लेखक".to_string();
-    writer.write_text_chunk(&tail_itxt_chunk).unwrap();
-}
diff --git a/vendor/png/examples/pngcheck.rs b/vendor/png/examples/pngcheck.rs
deleted file mode 100644
index 69e95e3..0000000
--- a/vendor/png/examples/pngcheck.rs
+++ /dev/null
@@ -1,381 +0,0 @@
-#![allow(non_upper_case_globals)]
-
-extern crate getopts;
-extern crate glob;
-extern crate png;
-
-use std::env;
-use std::fs::File;
-use std::io;
-use std::io::prelude::*;
-use std::path::Path;
-
-use getopts::{Matches, Options, ParsingStyle};
-use term::{color, Attr};
-
-fn parse_args() -> Matches {
-    let args: Vec<String> = env::args().collect();
-    let mut opts = Options::new();
-    opts.optflag("c", "", "colorize output (for ANSI terminals)")
-        .optflag("q", "", "test quietly (output only errors)")
-        .optflag(
-            "t",
-            "",
-            "print contents of tEXt/zTXt/iTXt chunks (can be used with -q)",
-        )
-        .optflag("v", "", "test verbosely (print most chunk data)")
-        .parsing_style(ParsingStyle::StopAtFirstFree);
-    if args.len() > 1 {
-        match opts.parse(&args[1..]) {
-            Ok(matches) => return matches,
-            Err(err) => println!("{}", err),
-        }
-    }
-    println!("{}", opts.usage("Usage: pngcheck [-cpt] [file ...]"));
-    std::process::exit(0);
-}
-
-#[derive(Clone, Copy)]
-struct Config {
-    quiet: bool,
-    verbose: bool,
-    color: bool,
-    text: bool,
-}
-
-fn display_interlaced(i: bool) -> &'static str {
-    if i {
-        "interlaced"
-    } else {
-        "non-interlaced"
-    }
-}
-
-fn display_image_type(bits: u8, color: png::ColorType) -> String {
-    use png::ColorType::*;
-    format!(
-        "{}-bit {}",
-        bits,
-        match color {
-            Grayscale => "grayscale",
-            Rgb => "RGB",
-            Indexed => "palette",
-            GrayscaleAlpha => "grayscale+alpha",
-            Rgba => "RGB+alpha",
-        }
-    )
-}
-// channels after expansion of tRNS
-fn final_channels(c: png::ColorType, trns: bool) -> u8 {
-    use png::ColorType::*;
-    match c {
-        Grayscale => 1 + u8::from(trns),
-        Rgb => 3,
-        Indexed => 3 + u8::from(trns),
-        GrayscaleAlpha => 2,
-        Rgba => 4,
-    }
-}
-fn check_image<P: AsRef<Path>>(c: Config, fname: P) -> io::Result<()> {
-    // TODO improve performance by resusing allocations from decoder
-    use png::Decoded::*;
-    let mut t = term::stdout()
-        .ok_or_else(|| io::Error::new(io::ErrorKind::Other, "could not open terminal"))?;
-    let data = &mut vec![0; 10 * 1024][..];
-    let mut reader = io::BufReader::new(File::open(&fname)?);
-    let fname = fname.as_ref().to_string_lossy();
-    let n = reader.read(data)?;
-    let mut buf = &data[..n];
-    let mut pos = 0;
-    let mut decoder = png::StreamingDecoder::new();
-    // Image data
-    let mut width = 0;
-    let mut height = 0;
-    let mut color = png::ColorType::Grayscale;
-    let mut bits = 0;
-    let mut trns = false;
-    let mut interlaced = false;
-    let mut compressed_size = 0;
-    let mut n_chunks = 0;
-    let mut have_idat = false;
-    macro_rules! c_ratio(
-        // TODO add palette entries to compressed_size
-        () => ({
-            compressed_size as f32/(
-                height as u64 *
-                (width as u64 * final_channels(color, trns) as u64 * bits as u64 + 7)>>3
-            ) as f32
-        });
-    );
-    let display_error = |err| -> Result<_, io::Error> {
-        let mut t = term::stdout()
-            .ok_or_else(|| io::Error::new(io::ErrorKind::Other, "could not open terminal"))?;
-        if c.verbose {
-            if c.color {
-                print!(": ");
-                t.fg(color::RED)?;
-                writeln!(t, "{}", err)?;
-                t.attr(Attr::Bold)?;
-                write!(t, "ERRORS DETECTED")?;
-                t.reset()?;
-            } else {
-                println!(": {}", err);
-                print!("ERRORS DETECTED")
-            }
-            println!(" in {}", fname);
-        } else {
-            if !c.quiet {
-                if c.color {
-                    t.fg(color::RED)?;
-                    t.attr(Attr::Bold)?;
-                    write!(t, "ERROR")?;
-                    t.reset()?;
-                    write!(t, ": ")?;
-                    t.fg(color::YELLOW)?;
-                    writeln!(t, "{}", fname)?;
-                    t.reset()?;
-                } else {
-                    println!("ERROR: {}", fname)
-                }
-            }
-            print!("{}: ", fname);
-            if c.color {
-                t.fg(color::RED)?;
-                writeln!(t, "{}", err)?;
-                t.reset()?;
-            } else {
-                println!("{}", err);
-            }
-        }
-        Ok(())
-    };
-
-    if c.verbose {
-        print!("File: ");
-        if c.color {
-            t.attr(Attr::Bold)?;
-            write!(t, "{}", fname)?;
-            t.reset()?;
-        } else {
-            print!("{}", fname);
-        }
-        print!(" ({}) bytes", data.len())
-    }
-    loop {
-        if buf.is_empty() {
-            // circumvent borrow checker
-            assert!(!data.is_empty());
-            let n = reader.read(data)?;
-
-            // EOF
-            if n == 0 {
-                println!("ERROR: premature end of file {}", fname);
-                break;
-            }
-            buf = &data[..n];
-        }
-        match decoder.update(buf, &mut Vec::new()) {
-            Ok((_, ImageEnd)) => {
-                if !have_idat {
-                    // This isn't beautiful. But it works.
-                    display_error(png::DecodingError::IoError(io::Error::new(
-                        io::ErrorKind::InvalidData,
-                        "IDAT chunk missing",
-                    )))?;
-                    break;
-                }
-                if !c.verbose && !c.quiet {
-                    if c.color {
-                        t.fg(color::GREEN)?;
-                        t.attr(Attr::Bold)?;
-                        write!(t, "OK")?;
-                        t.reset()?;
-                        write!(t, ": ")?;
-                        t.fg(color::YELLOW)?;
-                        write!(t, "{}", fname)?;
-                        t.reset()?;
-                    } else {
-                        print!("OK: {}", fname)
-                    }
-                    println!(
-                        " ({}x{}, {}{}, {}, {:.1}%)",
-                        width,
-                        height,
-                        display_image_type(bits, color),
-                        (if trns { "+trns" } else { "" }),
-                        display_interlaced(interlaced),
-                        100.0 * (1.0 - c_ratio!())
-                    )
-                } else if !c.quiet {
-                    println!();
-                    if c.color {
-                        t.fg(color::GREEN)?;
-                        t.attr(Attr::Bold)?;
-                        write!(t, "No errors detected ")?;
-                        t.reset()?;
-                    } else {
-                        print!("No errors detected ");
-                    }
-                    println!(
-                        "in {} ({} chunks, {:.1}% compression)",
-                        fname,
-                        n_chunks,
-                        100.0 * (1.0 - c_ratio!()),
-                    )
-                }
-                break;
-            }
-            Ok((n, res)) => {
-                buf = &buf[n..];
-                pos += n;
-                match res {
-                    Header(w, h, b, c, i) => {
-                        width = w;
-                        height = h;
-                        bits = b as u8;
-                        color = c;
-                        interlaced = i;
-                    }
-                    ChunkBegin(len, type_str) => {
-                        use png::chunk;
-                        n_chunks += 1;
-                        if c.verbose {
-                            let chunk = type_str;
-                            println!();
-                            print!("  chunk ");
-                            if c.color {
-                                t.fg(color::YELLOW)?;
-                                write!(t, "{:?}", chunk)?;
-                                t.reset()?;
-                            } else {
-                                print!("{:?}", chunk)
-                            }
-                            print!(
-                                " at offset {:#07x}, length {}",
-                                pos - 4, // substract chunk name length
-                                len
-                            )
-                        }
-                        match type_str {
-                            chunk::IDAT => {
-                                have_idat = true;
-                                compressed_size += len
-                            }
-                            chunk::tRNS => {
-                                trns = true;
-                            }
-                            _ => (),
-                        }
-                    }
-                    ImageData => {
-                        //println!("got {} bytes of image data", data.len())
-                    }
-                    ChunkComplete(_, type_str) if c.verbose => {
-                        use png::chunk::*;
-                        if type_str == IHDR {
-                            println!();
-                            print!(
-                                "    {} x {} image, {}{}, {}",
-                                width,
-                                height,
-                                display_image_type(bits, color),
-                                (if trns { "+trns" } else { "" }),
-                                display_interlaced(interlaced),
-                            );
-                        }
-                    }
-                    AnimationControl(actl) => {
-                        println!();
-                        print!("    {} frames, {} plays", actl.num_frames, actl.num_plays,);
-                    }
-                    FrameControl(fctl) => {
-                        println!();
-                        println!(
-                            "    sequence #{}, {} x {} pixels @ ({}, {})",
-                            fctl.sequence_number,
-                            fctl.width,
-                            fctl.height,
-                            fctl.x_offset,
-                            fctl.y_offset,
-                            /*fctl.delay_num,
-                            fctl.delay_den,
-                            fctl.dispose_op,
-                            fctl.blend_op,*/
-                        );
-                        print!(
-                            "    {}/{} s delay, dispose: {}, blend: {}",
-                            fctl.delay_num,
-                            if fctl.delay_den == 0 {
-                                100
-                            } else {
-                                fctl.delay_den
-                            },
-                            fctl.dispose_op,
-                            fctl.blend_op,
-                        );
-                    }
-                    _ => (),
-                }
-                //println!("{} {:?}", n, res)
-            }
-            Err(err) => {
-                let _ = display_error(err);
-                break;
-            }
-        }
-    }
-    if c.text {
-        println!("Parsed tEXt chunks:");
-        for text_chunk in &decoder.info().unwrap().uncompressed_latin1_text {
-            println!("{:#?}", text_chunk);
-        }
-
-        println!("Parsed zTXt chunks:");
-        for text_chunk in &decoder.info().unwrap().compressed_latin1_text {
-            let mut cloned_text_chunk = text_chunk.clone();
-            cloned_text_chunk.decompress_text()?;
-            println!("{:#?}", cloned_text_chunk);
-        }
-
-        println!("Parsed iTXt chunks:");
-        for text_chunk in &decoder.info().unwrap().utf8_text {
-            let mut cloned_text_chunk = text_chunk.clone();
-            cloned_text_chunk.decompress_text()?;
-            println!("{:#?}", cloned_text_chunk);
-        }
-    }
-
-    Ok(())
-}
-
-fn main() {
-    let m = parse_args();
-
-    let config = Config {
-        quiet: m.opt_present("q"),
-        verbose: m.opt_present("v"),
-        color: m.opt_present("c"),
-        text: m.opt_present("t"),
-    };
-
-    for file in m.free {
-        let result = if file.contains('*') {
-            glob::glob(&file)
-                .map_err(|err| io::Error::new(io::ErrorKind::Other, err))
-                .and_then(|mut glob| {
-                    glob.try_for_each(|entry| {
-                        entry
-                            .map_err(|err| io::Error::new(io::ErrorKind::Other, err))
-                            .and_then(|file| check_image(config, file))
-                    })
-                })
-        } else {
-            check_image(config, &file)
-        };
-
-        result.unwrap_or_else(|err| {
-            println!("{}: {}", file, err);
-            std::process::exit(1)
-        });
-    }
-}
diff --git a/vendor/png/examples/show.rs b/vendor/png/examples/show.rs
deleted file mode 100644
index d8ddf75..0000000
--- a/vendor/png/examples/show.rs
+++ /dev/null
@@ -1,198 +0,0 @@
-use glium::{
-    backend::glutin::Display,
-    glutin::{
-        self, dpi,
-        event::{ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent},
-        event_loop::ControlFlow,
-    },
-    texture::{ClientFormat, RawImage2d},
-    BlitTarget, Rect, Surface,
-};
-use std::{borrow::Cow, env, fs::File, io, path};
-
-/// Load the image using `png`
-fn load_image(path: &path::PathBuf) -> io::Result<RawImage2d<'static, u8>> {
-    use png::ColorType::*;
-    let mut decoder = png::Decoder::new(File::open(path)?);
-    decoder.set_transformations(png::Transformations::normalize_to_color8());
-    let mut reader = decoder.read_info()?;
-    let mut img_data = vec![0; reader.output_buffer_size()];
-    let info = reader.next_frame(&mut img_data)?;
-
-    let (data, format) = match info.color_type {
-        Rgb => (img_data, ClientFormat::U8U8U8),
-        Rgba => (img_data, ClientFormat::U8U8U8U8),
-        Grayscale => (
-            {
-                let mut vec = Vec::with_capacity(img_data.len() * 3);
-                for g in img_data {
-                    vec.extend([g, g, g].iter().cloned())
-                }
-                vec
-            },
-            ClientFormat::U8U8U8,
-        ),
-        GrayscaleAlpha => (
-            {
-                let mut vec = Vec::with_capacity(img_data.len() * 3);
-                for ga in img_data.chunks(2) {
-                    let g = ga[0];
-                    let a = ga[1];
-                    vec.extend([g, g, g, a].iter().cloned())
-                }
-                vec
-            },
-            ClientFormat::U8U8U8U8,
-        ),
-        _ => unreachable!("uncovered color type"),
-    };
-
-    Ok(RawImage2d {
-        data: Cow::Owned(data),
-        width: info.width,
-        height: info.height,
-        format,
-    })
-}
-
-fn main_loop(files: Vec<path::PathBuf>) -> io::Result<()> {
-    let mut files = files.into_iter();
-    let image = load_image(&files.next().unwrap())?;
-
-    let event_loop = glutin::event_loop::EventLoop::new();
-    let window_builder = glutin::window::WindowBuilder::new().with_title("Show Example");
-    let context_builder = glutin::ContextBuilder::new().with_vsync(true);
-    let display = glium::Display::new(window_builder, context_builder, &event_loop)
-        .map_err(|err| io::Error::new(io::ErrorKind::Other, err))?;
-    resize_window(&display, &image);
-    let mut texture = glium::Texture2d::new(&display, image).unwrap();
-    draw(&display, &texture);
-
-    event_loop.run(move |event, _, control_flow| match event {
-        Event::WindowEvent {
-            event: WindowEvent::CloseRequested,
-            ..
-        } => exit(control_flow),
-        Event::WindowEvent {
-            event:
-                WindowEvent::KeyboardInput {
-                    input:
-                        KeyboardInput {
-                            state: ElementState::Pressed,
-                            virtual_keycode: code,
-                            ..
-                        },
-                    ..
-                },
-            ..
-        } => match code {
-            Some(VirtualKeyCode::Escape) => exit(control_flow),
-            Some(VirtualKeyCode::Right) => match &files.next() {
-                Some(path) => {
-                    match load_image(path) {
-                        Ok(image) => {
-                            resize_window(&display, &image);
-                            texture = glium::Texture2d::new(&display, image).unwrap();
-                            draw(&display, &texture);
-                        }
-                        Err(err) => {
-                            println!("Error: {}", err);
-                            exit(control_flow);
-                        }
-                    };
-                }
-                None => exit(control_flow),
-            },
-            _ => {}
-        },
-        Event::RedrawRequested(_) => draw(&display, &texture),
-        _ => {}
-    });
-}
-
-fn draw(display: &glium::Display, texture: &glium::Texture2d) {
-    let frame = display.draw();
-    fill_v_flipped(
-        &texture.as_surface(),
-        &frame,
-        glium::uniforms::MagnifySamplerFilter::Linear,
-    );
-    frame.finish().unwrap();
-}
-
-fn exit(control_flow: &mut ControlFlow) {
-    *control_flow = ControlFlow::Exit;
-}
-
-fn fill_v_flipped<S1, S2>(src: &S1, target: &S2, filter: glium::uniforms::MagnifySamplerFilter)
-where
-    S1: Surface,
-    S2: Surface,
-{
-    let src_dim = src.get_dimensions();
-    let src_rect = Rect {
-        left: 0,
-        bottom: 0,
-        width: src_dim.0 as u32,
-        height: src_dim.1 as u32,
-    };
-    let target_dim = target.get_dimensions();
-    let target_rect = BlitTarget {
-        left: 0,
-        bottom: target_dim.1,
-        width: target_dim.0 as i32,
-        height: -(target_dim.1 as i32),
-    };
-    src.blit_color(&src_rect, target, &target_rect, filter);
-}
-
-fn resize_window(display: &Display, image: &RawImage2d<'static, u8>) {
-    let mut width = image.width;
-    let mut height = image.height;
-    if width < 50 && height < 50 {
-        width *= 10;
-        height *= 10;
-    }
-    display
-        .gl_window()
-        .window()
-        .set_inner_size(dpi::LogicalSize::new(f64::from(width), f64::from(height)));
-}
-
-fn main() {
-    let args: Vec<String> = env::args().collect();
-    if args.len() < 2 {
-        println!("Usage: show files [...]");
-    } else {
-        let mut files = vec![];
-        for file in args.iter().skip(1) {
-            match if file.contains('*') {
-                (|| -> io::Result<_> {
-                    for entry in glob::glob(file)
-                        .map_err(|err| io::Error::new(io::ErrorKind::Other, err.msg))?
-                    {
-                        files.push(
-                            entry
-                                .map_err(|_| io::Error::new(io::ErrorKind::Other, "glob error"))?,
-                        )
-                    }
-                    Ok(())
-                })()
-            } else {
-                files.push(path::PathBuf::from(file));
-                Ok(())
-            } {
-                Ok(_) => (),
-                Err(err) => {
-                    println!("{}: {}", file, err);
-                    break;
-                }
-            }
-        }
-        // "tests/pngsuite/pngsuite.png"
-        match main_loop(files) {
-            Ok(_) => (),
-            Err(err) => println!("Error: {}", err),
-        }
-    }
-}