loloof64

Tiles problem Relm

Feb 5th, 2020
653
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. use crate::solver::{Solution};
  2.  
  3. use gtk::{prelude::*, Inhibit, Orientation::{Horizontal, Vertical} };
  4. use relm::{Relm, Widget};
  5. use relm_derive::{Msg, widget};
  6.  
  7. #[derive(Msg)]
  8. pub enum TilesMsg {
  9.     Update(usize, u32),
  10. }
  11.  
  12. pub struct TilesModel {
  13. }
  14.  
  15. #[widget]
  16. impl Widget for TilesComp {
  17.     fn init_view(&mut self) {
  18.         for i in 0..6 {
  19.             self.set_model_in_tile(i);
  20.             self.connect_changed_event_in_tile(i);
  21.         }
  22.     }
  23.  
  24.     fn get_tile_component(&self, index: usize) -> &gtk::ComboBoxText {
  25.         match index {
  26.             0 => &self.tile_0,
  27.             1 => &self.tile_1,
  28.             2 => &self.tile_2,
  29.             3 => &self.tile_3,
  30.             4 => &self.tile_4,
  31.             5 => &self.tile_5,
  32.             _ => panic!("Incorrect tile index")
  33.         }
  34.     }
  35.  
  36.     fn set_model_in_tile(&mut self, tile_component_index: usize) {
  37.         let tile_component = self.get_tile_component(tile_component_index);
  38.  
  39.         let values = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 25, 50, 75, 100];
  40.  
  41.         for current in values.iter() {
  42.             tile_component.append_text(&current.to_string().to_owned());
  43.         }
  44.  
  45.         tile_component.set_active(Some(0));
  46.     }
  47.  
  48.     fn connect_changed_event_in_tile(&mut self, tile_component_index: usize) {
  49.         let tile_component = self.get_tile_component(tile_component_index);
  50.  
  51.         tile_component.connect_changed(move |comp| {
  52.             if let Some(id) = comp.get_active_id() {
  53.                 if let Ok(value) = id.parse::<u32>() {
  54.                     TilesMsg::Update(tile_component_index, value);
  55.                 }
  56.             }
  57.         });
  58.     }
  59.  
  60.     fn model(relm: &Relm<Self>, _: ()) -> TilesModel {
  61.         TilesModel {
  62.         }
  63.     }
  64.  
  65.     fn update(&mut self, event: TilesMsg) {
  66.         match event {
  67.             TilesMsg::Update(index, new_val) => {},
  68.         }
  69.     }
  70.  
  71.     view! {
  72.         gtk::Box {
  73.             orientation: Horizontal,
  74.             spacing: 4,
  75.  
  76.             #[name="tile_0"]
  77.             gtk::ComboBoxText {
  78.                 id_column: 0,
  79.             },
  80.  
  81.             #[name="tile_1"]
  82.             gtk::ComboBoxText {
  83.                 id_column: 0,
  84.             },
  85.  
  86.             #[name="tile_2"]
  87.             gtk::ComboBoxText {
  88.                 id_column: 0,
  89.             },
  90.  
  91.             #[name="tile_3"]
  92.             gtk::ComboBoxText {
  93.                 id_column: 0,
  94.             },
  95.  
  96.             #[name="tile_4"]
  97.             gtk::ComboBoxText {
  98.                 id_column: 0,
  99.             },
  100.  
  101.             #[name="tile_5"]
  102.             gtk::ComboBoxText {
  103.                 id_column: 0,
  104.             },
  105.         }
  106.     }
  107. }
  108.  
  109. #[derive(Msg)]
  110. pub enum TargetNumberMsg {
  111.     Update(u32),
  112. }
  113.  
  114. pub struct TargetNumberModel {
  115.     value: u32,
  116. }
  117.  
  118. #[widget]
  119. impl Widget for TargetNumberComp {
  120.     fn model() -> TargetNumberModel {
  121.         TargetNumberModel {
  122.             value: 0,
  123.         }
  124.     }
  125.  
  126.     fn update(&mut self, event: TargetNumberMsg) {
  127.         match event {
  128.             TargetNumberMsg::Update(new_val) => self.model.value = new_val,
  129.         }
  130.     }
  131.  
  132.     view! {
  133.         gtk::Box {
  134.             orientation: Horizontal,
  135.             gtk::Label {
  136.                 justify: gtk::Justification::Center,
  137.                 text: &self.model.value.to_string(),
  138.                 hexpand: true,
  139.             },
  140.  
  141.         }
  142.     }
  143. }
  144.  
  145. pub struct SolutionModel {
  146.  
  147. }
  148.  
  149. #[derive(Msg)]
  150. pub enum SolutionMsg {
  151.  
  152. }
  153.  
  154. #[widget]
  155. impl Widget for SolutionComponent {
  156.     fn init_view(&mut self) {
  157.         self.current_solution.get_buffer().unwrap().set_text("\n\n\n\n");
  158.     }
  159.  
  160.     fn model() -> SolutionModel {
  161.         SolutionModel {}
  162.     }
  163.  
  164.     fn update(&mut self, msg: SolutionMsg) {
  165.  
  166.     }
  167.  
  168.     view! {
  169.         gtk::Box {
  170.             orientation: Vertical,
  171.             gtk::Box {
  172.                 orientation: Horizontal,
  173.                 spacing: 4,
  174.                 homogeneous: true,
  175.                 gtk::Button {
  176.                     label: "|<"
  177.                 },
  178.                 gtk::Button {
  179.                     label: "<"
  180.                 },
  181.                 gtk::Button {
  182.                     label: ">"
  183.                 },
  184.                 gtk::Button {
  185.                     label: ">|"
  186.                 },
  187.             },
  188.             #[name="current_solution"]
  189.             gtk::TextView {
  190.                 editable: false,
  191.  
  192.             }
  193.         }
  194.     }
  195. }
  196.  
  197. pub struct AppModel {
  198.     tiles: [u32; 6],
  199. }
  200.  
  201. #[derive(Msg)]
  202. pub enum AppMsg {
  203.     Quit,
  204.     Solve,
  205.     UpdateTile(usize, u32),
  206. }
  207.  
  208. #[widget]
  209. impl Widget for Win {
  210.     fn model() -> AppModel {
  211.         AppModel {
  212.             tiles: [0; 6],
  213.         }
  214.     }
  215.  
  216.     fn update(&mut self, event: AppMsg) {
  217.         match event {
  218.             AppMsg::Quit => gtk::main_quit(),
  219.             AppMsg::Solve => self.solve(),
  220.             AppMsg::UpdateTile(index, new_val) => self.model.tiles[index] = new_val,
  221.         }
  222.     }
  223.  
  224.     fn solve(&mut self) {
  225.         /////////////////////////////////////
  226.         println!("{}", self.model.tiles);
  227.         /////////////////////////////////////
  228.     }
  229.  
  230.     view! {
  231.         gtk::Window {
  232.             gtk::Box {
  233.                 orientation: Vertical,
  234.                 spacing: 4,
  235.  
  236.                 #[name="tiles"]
  237.                 TilesComp {
  238.                     TilesMsg::Update(index, new_val) => AppMsg::UpdateTile(index, new_val), /// HERE !!!
  239.                 },
  240.                
  241.                 #[name="target"]
  242.                 TargetNumberComp {},
  243.  
  244.                 gtk::Button {
  245.                     label: "Solve",
  246.                     hexpand: true,
  247.                     clicked(_) => AppMsg::Solve,
  248.                 },
  249.  
  250.                 SolutionComponent {},
  251.             },
  252.  
  253.             delete_event(_, _) => (AppMsg::Quit, Inhibit(false)),
  254.         }
  255.     }
  256. }
  257.  
  258. pub fn run() {
  259.     Win::run(()).expect("Failed to build window.");
  260. }
RAW Paste Data

Adblocker detected! Please consider disabling it...

We've detected AdBlock Plus or some other adblocking software preventing Pastebin.com from fully loading.

We don't have any obnoxious sound, or popup ads, we actively block these annoying types of ads!

Please add Pastebin.com to your ad blocker whitelist or disable your adblocking software.

×