extern crate glium;
extern crate glob;
extern crate png;
use std::env;
use std::io;
use std::fs::File;
use std::borrow::Cow;
use std::path;
use std::error::Error;
use glium::{Surface, Rect, BlitTarget};
use glium::texture::{RawImage2d, ClientFormat};
use glium::glutin::{self, Event, VirtualKeyCode, dpi};
use glium::backend::glutin::Display;
fn load_image(path: &path::PathBuf) -> io::Result<RawImage2d<'static, u8>> {
use png::ColorType::*;
let decoder = png::Decoder::new(File::open(path)?);
let (info, mut reader) = decoder.read_info()?;
let mut img_data = vec![0; info.buffer_size()];
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: format
})
}
fn main_loop(files: Vec<path::PathBuf>) -> io::Result<()> {
use glium::glutin::{KeyboardInput, WindowEvent};
let mut files = files.iter();
let image = load_image(files.next().unwrap())?;
let mut events_loop = glutin::EventsLoop::new();
let window = glutin::WindowBuilder::new();
let context = glutin::ContextBuilder::new()
.with_vsync(true);
let display = Display::new(window, context, &events_loop)
.map_err(|err| io::Error::new(
io::ErrorKind::Other,
err.description()
))?;
resize_window(&display, &image);
let mut opengl_texture = glium::Texture2d::new(&display, image).unwrap();
let mut stop = false;
let mut res = Ok(());
'main: loop {
let frame = display.draw();
fill_v_flipped(&opengl_texture.as_surface(), &frame, glium::uniforms::MagnifySamplerFilter::Linear);
frame.finish().unwrap();
events_loop.poll_events(|event| {
if stop {return;}
match event {
Event::WindowEvent {event: WindowEvent::CloseRequested, ..} => {
stop = true;
return;
}
Event::WindowEvent {
event: WindowEvent::KeyboardInput {
input: KeyboardInput {
state: glutin::ElementState::Pressed,
virtual_keycode: code,
..
},
..
},
..
} => match code {
Some(VirtualKeyCode::Escape) => {
stop = true;
return;
}
Some(VirtualKeyCode::Right) => {
match files.next() {
Some(path) => {
let image = match load_image(path) {
Ok(image) => image,
Err(err) => {
stop = true;
res = Err(err);
return;
}
};
resize_window(&display, &image);
opengl_texture = glium::Texture2d::new(&display, image).unwrap();
},
None => {
stop = true;
return;
}
}
},
_ => ()
},
_ => ()
}
});
if stop {break 'main;}
}
res
}
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;
} else if width < 5 && height < 5 {
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
}
}
}
match main_loop(files) {
Ok(_) => (),
Err(err) => println!("Error: {}", err)
}
}
}