src/main.rs

   1 //#![feature(slice_patterns)]
   2 #[macro_use] extern crate conrod;
   3 extern crate find_folder;
   4 extern crate piston_window;
   5 extern crate graphics;
   6 extern crate rand;
   7 extern crate input;
   8 extern crate image;
   9 extern crate gfx_device_gl;
  10
  11
  12 mod data;
  13 use data::*;
  14
  15 mod display;
  16 use display::*;
  17
  18 use conrod::Theme;
  19 use conrod::color;
  20 use conrod::events::input_provider::InputProvider;
  21 use piston_window::{
  22     Glyphs, OpenGL, PistonWindow, WindowSettings, UpdateEvent, EventLoop,
  23     Window, ImageSize
  24 };
  25 use input::keyboard::Key;
  26 use graphics::{Transformed, Image, DrawState};
  27
  28 fn handle_keys(ui: &Ui, d: &mut Data) {
  29     let mut keys = ui.global_input.keys_just_pressed().collect::<Vec<_>>();
  30     keys.dedup();
  31     for k in keys {
  32         println!("{:?}", k);
  33         match k {
  34             Key::R => d.space.rotate(),
  35             Key::E => d.space.set_pos_kind(PosKind::Edge),
  36             Key::F => d.space.set_pos_kind(PosKind::Face),
  37             Key::N => d.load_next_if_any(),
  38             Key::P => d.load_prev_if_any(),
  39             _ => match d.space.current {
  40                 Pos::E((_, a)) => match k {
  41                     Key::PageUp => d.space.inc_size(),
  42                     Key::PageDown => d.space.dec_size(),
  43                     _ => match a {
  44                         Axis::X => match k {
  45                             Key::Right => d.space.inc_pos(),
  46                             Key::Left => d.space.dec_pos(),
  47                             _ => {},
  48                         },
  49                         Axis::Y => match k {
  50                             Key::Up => d.space.dec_pos(),
  51                             Key::Down => d.space.inc_pos(),
  52                             _ => {},
  53                         },
  54                         Axis::Z => match k {
  55                             Key::Up => d.space.dec_pos(),
  56                             Key::Down => d.space.inc_pos(),
  57                             _ => {},
  58                         },
  59                     },
  60                 },
  61                 Pos::F((_, o)) => match k {
  62                         Key::A => d.space.set_current_face_if_none(),
  63                         _ => match o {
  64                             Ori::Top => match k {
  65                                 Key::Up => d.space.dec_pos(),
  66                                 Key::Down => d.space.inc_pos(),
  67                                 _ => {},
  68                             },
  69                             Ori::Back => match k {
  70                                 Key::Down => d.space.dec_pos(),
  71                                 Key::Up => d.space.inc_pos(),
  72                                 _ => {},
  73                             },
  74                             Ori::Side => match k {
  75                                 Key::Left => d.space.dec_pos(),
  76                                 Key::Right => d.space.inc_pos(),
  77                                 _ => {},
  78                         },
  79                     },
  80                 },
  81             },
  82         };
  83     }
  84 }
  85
  86 fn main() {
  87     let opengl = OpenGL::V3_2;
  88     let mut window: PistonWindow = WindowSettings::new("LP74", [900, 600])
  89         .opengl(opengl).exit_on_esc(true).build().unwrap();
  90
  91         let mut ui = {
  92         let assets = find_folder::Search::KidsThenParents(3, 5)
  93             .for_folder("assets").expect("Cannot find assets folder");
  94         let font_path = assets.join("fonts/NotoSans/NotoSans-Regular.ttf");
  95         let theme = Theme::default();
  96         let glyph_cache = Glyphs::new(&font_path, window.factory.clone());
  97         Ui::new(glyph_cache.unwrap(), theme)
  98     };
  99
 100     window.set_ups(30);
 101     window.set_max_fps(30);
 102
 103     let mut colors = Colors {
 104         c1: color::rgb_bytes(57, 63, 63),
 105         c2: color::rgb_bytes(30, 34, 34),
 106         font: color::WHITE,
 107         hide: color::rgba_bytes(57, 63, 63, 0.4),
 108     };
 109
 110     let mut state = State::Design;
 111     let mut data = Data::new();
 112
 113     while let Some(event) = window.next() {
 114         let wsize = WSize {
 115             header_h: 50.0,
 116             side_w: 150.0,
 117             w: window.size().width as f64,
 118             h: window.size().height as f64
 119         };
 120
 121         ui.handle_event(&event);
 122         event.update(|_| ui.set_widgets(|ref mut uicell|
 123                                         set_ui(uicell,
 124                                                &mut state,
 125                                                &mut data,
 126                                                &mut colors,
 127                                                &wsize)));
 128         state = match state {
 129             State::Visual(faces_map) => match faces_map {
 130                 None => match generate_faces_map(&mut window, &data.space) {
 131                         None => State::Err(String::from("Graphviz project's \"dot\" is not installed")),
 132                         fmap_opt => State::Visual(fmap_opt),
 133                 },
 134                 Some(_) => State::Visual(faces_map),
 135             },
 136             State::Design => {
 137                 handle_keys(&ui, &mut data);
 138                 State::Design
 139             },
 140             State::Extensions => State::Err(String::from("Not implemented")),
 141             s => s,
 142         };
 143         window.draw_2d(&event, |c, g| {
 144             match &state {
 145                 &State::Design => {
 146                     println!("space {}", data.space.change != Change::None);
 147                     println!("history {}", data.history.change);
 148                     println!("ui {}", ui.will_redraw());
 149                     if data.space.change != Change::None
 150                         || data.history.change
 151                         || ui.will_redraw() {
 152                         data.history.change = false;
 153                         piston_window::clear([0.0, 0.0, 0.0, 0.0], g);
 154                         show_space(&data.space, &wsize, c, g);
 155                         ui.needs_redraw();
 156                     }
 157                     data.save_if_changed();
 158                 },
 159                 &State::Visual(ref faces_map) => {
 160                     if ui.will_redraw() {
 161                         if let &Some(ref m) = faces_map {
 162                             piston_window::clear([1.0, 1.0, 1.0, 1.0], g);
 163                             let image = Image::new()
 164                                 .rect(final_size(wsize,
 165                                                  (m.get_width() as f64,
 166                                                   (m.get_height()) as f64)));
 167                             image.draw(m, &DrawState::default(),
 168                                        c.transform.trans(0.0, 0.0), g);
 169                             ui.needs_redraw();
 170                         }
 171                     }
 172                 },
 173                 &State::Extensions => {},
 174                 &State::Err(_) => {},
 175             }
 176             ui.draw_if_changed(c, g);
 177         });
 178     }
 179 }