closes #11

README.md

@@ -11,14 +11,3 @@
 [Tanach.us](https://tanach.us)
 
 [AndBible's formats](https://github.com/AndBible/and-bible/wiki/Supported-3rd-party-module-formats)
-
-## TODOs
-
-- [ ]: When 1 scripture is open; put a button to view full chapter in new col
-- [ ]: Button to add new col, same translation
-- [ ]: Save all cols to file button
-- [ ]: Only have 1 chapter/translation header for verse range copy
-- [ ]: Pane widget could work for cols
-- [ ]: Notes block at bottom of each col
-- [ ]: Program doesn't wake back up from sleep very well
-

src/main.rs

@@ -2,16 +2,18 @@
 use iced::keyboard::key::Named;
 use iced::keyboard::{Key, Modifiers};
 use iced::{event, Event, Subscription};
-use iced::widget::scrollable;
+use iced::widget::{scrollable, text_editor};
 use iced::{
     Element, Length, Task, Theme, clipboard, color,
     widget::{
-        self, button, column, combo_box, row,
+        button, column, combo_box, row,
         scrollable::{Direction, Scrollbar},
         text, text_input,
     },
 };
 
+use std::fs::OpenOptions;
+use std::io::{BufWriter, Write};
 use std::{env, fs, path::PathBuf};
 use texts::*;
 
@@ -35,7 +37,7 @@ fn main() -> iced::Result {
                     if let Ok(f) = bible::get(
                         query,
                         second_query,
-                        vec![&bible],
+                        &bible,
                     ) {
                         println!("{}", f);
                     }
@@ -68,6 +70,8 @@ enum Message {
     DeleteColumn(usize),
     SetErrorMessage(usize, String),
     RecievedEvent(Event),
+    NoteInput(usize, text_editor::Action),
+    Save,
 }
 
 impl Message {
@@ -82,7 +86,8 @@ impl Message {
             Message::WordSearchInput(i, _) |
             Message::SubmitWordSearch(i) |
             Message::QuickSearch(i, _, _) |
-            Message::DeleteColumn(i)
+            Message::DeleteColumn(i) |
+            Message::NoteInput(i, _)
             => {
                 Some(*i)
             },
@@ -92,7 +97,7 @@ impl Message {
 }
 
 struct ColState {
-    selected_file: Option<String>,
+    file: Option<String>,
     bible_selected: Option<bible::Bible>,
 
     bible_search: String,
@@ -101,13 +106,15 @@ struct ColState {
     word_search: String,
     word_search_results: Option<Vec<(String, bool)>>,
 
+    notes: text_editor::Content,
+
     error: Option<String>,
 }
 
 impl Default for ColState {
     fn default() -> Self {
         Self {
-            selected_file: None,
+            file: None,
             bible_selected: None,
 
             bible_search: String::new(),
@@ -116,6 +123,8 @@ impl Default for ColState {
             word_search: String::new(),
             word_search_results: None,
 
+            notes: text_editor::Content::new(),
+
             error: None,
         }
     }
@@ -124,7 +133,7 @@ impl Default for ColState {
 struct State {
     files: combo_box::State<String>,
     states: Vec<ColState>,
-    cols: usize,
+    // cols: usize,
     tab_index: Option<i32>,
 
     theme_idx: usize,
@@ -159,7 +168,7 @@ impl Default for State {
         Self {
             files: combo_box::State::new(files),
             states: vec![ColState::default()],
-            cols: 1,
+            // cols: 1,
             tab_index: None,
             // THEMES
             //    Dark - KanagawaDragon
@@ -191,6 +200,45 @@ impl State {
         }
         // match normal messages
         match msg {
+            Message::Save => {
+                let opt = OpenOptions::new()
+                    // create if doesn't already exist
+                    .create(true)
+                    .append(false)
+                    // clear existing file
+                    .truncate(true)
+                    .write(true)
+                    .open("save.md")
+                    ;
+                match opt {
+                    Ok(file) => {
+                        let mut buffer = BufWriter::new(file);
+
+                        // the toml heading at the top of md files
+                        let _ = buffer.write_all("---\n---\n".as_bytes());
+
+                        for col in &self.states {
+                            // separate each col with hr
+                            let _ = buffer.write_all("\n---\n".as_bytes());
+                            if let Some(scripture) = &col.scripture_body {
+                                // code block for scripture
+                                let _ = buffer.write_all("```\n".as_bytes());
+                                let _ = buffer.write_all(parse(scripture).as_bytes());
+                                let _ = buffer.write_all("```\n".as_bytes());
+                            }
+                            let _ = buffer.write_all(&col.notes.text().as_bytes());
+                        }
+                        let _ = buffer.flush();
+                    },
+                    Err(err) => {
+                        eprintln!("{err}");
+                    }
+                }
+            },
+            Message::NoteInput(i, action) => {
+                let notes = &mut self.states[i].notes;
+                notes.perform(action);
+            },
             Message::CycleTheme => {
                 let len = self.themes.len();
                 let i = &mut self.theme_idx;
@@ -209,13 +257,13 @@ impl State {
                                     let new_idx = if modifiers == Modifiers::SHIFT { idx-1 } else { idx+1 };
 
                                     // 2 because two buttons on each col
-                                    let new_idx = new_idx.clamp(0, (self.cols*2) as i32 -1);
+                                    let new_idx = new_idx.clamp(0, (self.states.len()*2) as i32 -1);
                                     self.tab_index = Some(new_idx);
 
                                     let id = format!("tabId-{}", new_idx);
                                     return text_input::focus(id);
                                 } else {
-                                    if self.cols > 0 {
+                                    if self.states.len() > 0 {
                                         self.tab_index = Some(0);
                                         return text_input::focus("tabId-0");
                                     }
@@ -229,14 +277,20 @@ impl State {
                 self.states[i].error = Some(m);
             }
             Message::DeleteColumn(idx) => {
-                self.cols -= 1;
+                // self.cols -= 1;
                 self.states.remove(idx);
             }
             Message::AddColRight => {
-                self.cols += 1;
+                self.states.push(ColState::default());
-                // clone this state into the new one
+
-                // self.states.push(self.states.into_iter().last().unwrap().clone())
+                // Add the rightmost opened Bible to the new column
-                self.states.push(ColState::default())
+                if let Some(last) = self.states.get(self.states.len()-2) {
+                    let file = &last.file;
+                    if let Some(file) = file {
+                        return self.update(Message::BibleSelected(self.states.len()-1, file.to_string())); 
+                    }
+                }; 
+                
             }
             Message::BibleSelected(i, file) => {
                 match fs::read_to_string(&file) {
@@ -245,8 +299,8 @@ impl State {
                             Ok(bible)  => {
                                 // State is held technically in this variable, although
                                 // the Bible is held in memory in it's own variable.
-                                self.states[i].selected_file = Some(format!("{bible}"));
                                 self.states[i].bible_selected = Some(bible);
+                                self.states[i].file = Some(file);
 
                             }
                             Err(err) => {
@@ -279,7 +333,7 @@ impl State {
                 if let (Some(book), Some(chap_and_ver), Some(bible)) =
                     (book, location, &self.states[i].bible_selected)
                 {
-                    self.states[i].scripture_body = match bible::get(book, chap_and_ver, vec![bible]) {
+                    self.states[i].scripture_body = match bible::get(book, chap_and_ver, bible) {
                         Ok(s) => {
                             Some(s)
                         },
@@ -326,33 +380,49 @@ impl State {
     }
 
     fn view(&self) -> Element<Message> {
-        //TODO error message
+
+        // TODO make this dynamic
+        // max height that the scripture body can be
+        // max height that the search resutls can be
+        let max_height = 600;
+
+        // Header bar, static, doesn't scroll
         column![
-            button("Cycle Themes")
-                .on_press(Message::CycleTheme)
-                .style(button::secondary),
-        scrollable(
             row![
-                row((0..self.cols).map(|col_index| {
+                button("Cycle Themes")
+                    .on_press(Message::CycleTheme)
+                    .style(button::secondary)
+                    ,
+                button("Save")
+                    .on_press(Message::Save)
+                    .style(button::secondary)
+                    ,
+            ],
+       scrollable(
+            row![
+                row((0..self.states.len()).map(|col_index| {
                     column![
-                        // header
+                        // Top of Column, text entry boxes
                         combo_box(
                             &self.files,
                             "Select Bible",
-                            self.states[col_index].selected_file.as_ref(),
+                            // Some(&"IDK where this text is".to_string()),
+                            match &self.states[col_index].bible_selected {
+                                Some(b) => Some(&b.translation_name),
+                                None => None,
+                            },
                             move |s| Message::BibleSelected(col_index, s)
                         ),
-                        text_input(
+                        text_input("Search query, ie: Gen 1:1", &self.states[col_index].bible_search)
-                            "Search query, ie: Gen 1:1",
+                            .id(format!("tabId-{}", (col_index*2)+0))
-                            &self.states[col_index].bible_search
+                            .on_input(move |s| Message::BibleSearchInput(col_index, s))
-                        )
+                            .on_submit(Message::BibleSearchSubmit(col_index)),
-                        .id(format!("tabId-{}", (col_index*2)+0))
+                        text_input("Word Search", &self.states[col_index].word_search)
-                        .on_input(move |s| Message::BibleSearchInput(col_index, s))
-                        .on_submit(Message::BibleSearchSubmit(col_index)),
-                        widget::text_input("Word Search", &self.states[col_index].word_search)
                             .id(format!("tabId-{}", (col_index*2)+1))
                             .on_input(move |s| Message::WordSearchInput(col_index, s))
                             .on_submit(Message::SubmitWordSearch(col_index)),
+
+                        // Horizontal Row just above scripture
                         row![
                             button("Clear All")
                                 .on_press_with(move || Message::Clear(col_index))
@@ -367,6 +437,7 @@ impl State {
                                 .style(text::danger),
                         ]
                         .spacing(5),
+                        // Body
                         row![
                             // Word search results
                             scrollable(
@@ -395,11 +466,13 @@ impl State {
                                 )
                                 .padding([5, 5])
                             )
+                            .height(max_height)
                             .spacing(5),
-                            // Body
+                            // Scripture
                             scrollable(
                                 if let Some(body) = &self.states[col_index].scripture_body {
                                     column(body.split("\n").enumerate().map(|(i, msg)| {
+                                        // Color every other verse slightly differently
                                         let msg = parse(msg);
                                         if i & 1 == 0 {
                                             text(msg.to_owned()).color(color![0xFFFFFF]).into()
@@ -415,13 +488,21 @@ impl State {
                                     )
                                 }
                             )
+                            .height(max_height)
                             .spacing(5)
                         ],
+                        // Notes
+                        text_editor(&self.states[col_index].notes)
+                            .placeholder("Notes...")
+                            .on_action(move |a| Message::NoteInput(col_index, a))
+                            .height(100)
+                            // .id(format!("tabId-{}", (col_index*2)+2))
                     ]
                     .spacing(5)
                     .width(800.)
                     .into()
                 })),
+                // Right most vertical buttons
                 button(text("+").center())
                     .height(Length::Fixed(200.))
                     .style(button::primary)

src/texts/bible.rs

@@ -102,19 +102,9 @@ pub fn search_for_word(word: &str, from_files: &Bible) -> Vec<String> {
     found
 }
 
-pub fn get(book: &str, chap_and_ver: &str, bibles: Vec<&Bible>) -> Result<String, String> {
+fn parse_book(book: &str) -> Result<(usize, &str), String> {
-    // expecting query to be in format:
+    // Go thru the list of books and see which
-    // Gen 1:2
+    // match the passed book str
-    // Gen 1:2-5
-    // Gen 1
-    // The book name needs to be just long enough to be unique
-
-    let mut splits = chap_and_ver.split(':');
-    let chapter = splits.next();
-    let verse = splits.next();
-
-    // ###########################################
-    // Figure out what book they are talking about
     let res = BOOKS_IN_ORDER
         .iter()
         .enumerate()
@@ -129,7 +119,9 @@ pub fn get(book: &str, chap_and_ver: &str, bibles: Vec<&Bible>) -> Result<String
         .collect::<Vec<(usize, &&str)>>();
 
     let (book_idx, book_name) = match res.len() {
+        // there is one option for what book it is
         1 => res[0],
+        // there are >1 options for what book it is
         2.. => {
             eprintln!("Err: Ambigious input '{book}', could be any of:");
             for (_, i) in &res {
@@ -142,34 +134,51 @@ pub fn get(book: &str, chap_and_ver: &str, bibles: Vec<&Bible>) -> Result<String
             return Err(format!("'{book}' is not a book"));
         }
     };
+    Ok((book_idx, book_name))
+}
 
-    // Select the book in each Bible
+fn parse_chapter<'a>(chapter_num: &str, book: &'a Book) -> Result<&'a Chapter, String> {
-    let books = bibles
+    let chapter = if let Ok(idx) = chapter_num.parse::<usize>() {
-        .iter()
+        if let Some(chapter) = book.get_chapter_by_index(idx) {
-        // Book are 1 indexed in the xml spec
+            chapter
-        .map(|bible| (bible, bible.get_book_by_index(book_idx + 1)))
-        .filter(|(_,e)| e.is_some())
-        .map(|(bible,book)| (*bible,book.unwrap()))
-        .collect::<Vec<(&Bible,&Book)>>();
-
-    // Select the chapter in each Bible
-    let chapters = if let Some(chapter) = chapter {
-        if let Ok(ch_num) = chapter.parse::<usize>() {
-            books
-                .iter()
-                .map(|(bible,book)| (bible, book, book.get_chapter_by_index(ch_num)))
-                .filter(|(_,_,book)| book.is_some())
-                .map(|(bible,book,chapter)| (*bible,*book,chapter.unwrap()))
-                .collect::<Vec<(&Bible, &Book, &Chapter)>>()
         } else {
-            return Err(format!("Chapter number could not be parsed from {chapter}"));
+            return Err(format!("Chapter {idx} doesn't exist in book {}", BOOKS_IN_ORDER[book.number-1]));
         }
     } else {
-        return Err(format!("A chapter was not passed"));
+        return Err(format!("Chapter number could not be parsed from {chapter_num}"));
+    };
+    Ok(chapter)
+}
+
+pub fn get(book: &str, chap_and_ver: &str, bible: &Bible) -> Result<String, String> {
+    // expecting query to be in format:
+    // Gen 1:2
+    // Gen 1:2-5
+    // Gen 1
+    // The book name needs to be just long enough to be unique
+
+    let mut splits = chap_and_ver.split(':');
+    let chapter_num = splits.next();
+    let verse_num = splits.next();
+    // ###########################################
+
+    // Figure out what book they are talking about
+    let (book_idx, book_name) = parse_book(book)?;
+
+    let book = match bible.get_book_by_index(book_idx+1) {
+        Some(s) => s,
+        None => return Err(format!("Selected Bible {} doesn't contain book {book_name}", bible.translation_name)),
+    };
+
+    // Figure out what chapter they are talking about
+    let chapter = if let Some(ch) = chapter_num {
+        parse_chapter(ch, book)?
+    } else {
+        return Err("No chapter number was passed".to_string());
     };
 
     // Get the verse in each Bible
-    match verse {
+    match verse_num {
         Some(verse) => {
             let mut splits = verse.split("-");
             let start = splits.next();
@@ -180,14 +189,15 @@ pub fn get(book: &str, chap_and_ver: &str, bibles: Vec<&Bible>) -> Result<String
                 (Some(sn), Some(en)) => {
                     if let (Ok(start), Ok(end)) = (sn.parse::<usize>(), en.parse::<usize>()) {
                         let mut buf = String::new();
+
+                        let translation = &bible.translation_name;
+
+                        buf += &format!("{style_bold}[{translation}] {style_underline}{book_name} {}:{start}-{end}{style_reset}:\n", chapter.number);
                         for num in start..=end {
-                            for (bible, _book, chapter) in &chapters {
+                            if let Some(verse) = chapter.get_verse_by_index(num) {
-                                if let Some(verse) = chapter.get_verse_by_index(num) {
+                                buf += &format!(
-                                    buf += &format!(
+                                    "{}: {verse}\n", verse.number
-                                        "{style_bold}[{}] {style_underline}{book_name} {}:{}{style_reset}: {verse}\n",
+                                );
-                                        bible.translation_name, chapter.number, verse.number
-                                    );
-                                }
                             }
                         }
                         return Ok(buf);
@@ -198,13 +208,11 @@ pub fn get(book: &str, chap_and_ver: &str, bibles: Vec<&Bible>) -> Result<String
                 (Some(ver_num), None) => {
                     if let Ok(num) = ver_num.parse::<usize>() {
                         let mut buf = String::new();
-                        for (bible, _book, chapter) in chapters {
+                        if let Some(verse) = chapter.get_verse_by_index(num) {
-                            if let Some(verse) = chapter.get_verse_by_index(num) {
+                            buf += &format!(
-                                buf += &format!(
+                                "{style_bold}[{}] {style_underline}{book_name} {}:{}{style_reset}:\n{verse}\n",
-                                    "{style_bold}[{}] {style_underline}{book_name} {}:{}{style_reset}: {verse}\n",
+                                bible.translation_name, chapter.number, verse.number
-                                    bible.translation_name, chapter.number, verse.number
+                            );
-                                );
-                            }
                         }
                         return Ok(buf);
                     }
@@ -219,13 +227,11 @@ pub fn get(book: &str, chap_and_ver: &str, bibles: Vec<&Bible>) -> Result<String
         None => {
             // only chapter
             let mut buf = String::new();
-            for (bible, _, chapter) in chapters {
+            buf += &format!(
-                buf += &format!(
+                "{style_bold}[{}] {style_underline}{book_name} {}{style_reset}:\n",
-                    "{style_bold}[{}] {style_underline}{book_name} {}{style_reset}:\n",
+                bible.translation_name, chapter.number
-                    bible.translation_name, chapter.number
+            );
-                );
+            buf += &format!("{}", chapter);
-                buf += &format!("{}", chapter);
-            }
             return Ok(buf);
         }
     }
@@ -269,15 +275,10 @@ impl Chapter {
 #[derive(Deserialize)]
 pub struct Bible {
     #[serde(rename = "@translation")]
-    translation_name: String,
+    pub translation_name: String,
     #[serde(rename = "testament")]
     testaments: Vec<Testament>,
 }
-impl Display for Bible {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}",self.translation_name)
-    }
-}
 
 #[derive(Deserialize)]
 struct Testament {
@@ -291,6 +292,7 @@ struct Testament {
 #[derive(Deserialize)]
 struct Book {
     #[serde(rename = "@number")]
+    /// Genesis is book 1
     number: usize,
     #[serde(rename = "chapter")]
     chapters: Vec<Chapter>,