hen6003/gemini-client - Change VNHV4C2GHMQ4FNWXIAN7WE2KP4ZBMFLDXS276V4TAUCI26QUEFVQC

Add save file dialogs

Created by hen6003 on July 16, 2022

VNHV4C2GHMQ4FNWXIAN7WE2KP4ZBMFLDXS276V4TAUCI26QUEFVQC

Dependencies

[2] PNYL4BRD4OU3T5F4N5HWAKROS4SW2F3C4VF4JUAMTLLFVRA55SMAC

In channels

main

Change contents

Insertion in src/main.rs at line 8 [2.976]
[2.1086]
[2.1086]
```
use std::fs;
```
Replacement in src/main.rs at line 16 [2.976]
B:BD[2.1241] → [2.1241:1264]
```
    url: Vec<String>,
```
[2.1241]
[2.1264]
```
    url_history: Vec<String>,
```

Replacement in src/main.rs at line 32 [2.976]

B:BD[2.1574] → [2.1574:1663]

            url: Vec::new(),
            url_bar: "gemini://gem.hen6003.xyz".to_owned(),

[2.1574]

[2.1663]

            url_history: vec!["gemini://gem.hen6003.xyz/".to_owned()],
            url_bar: String::new(),

Insertion in src/main.rs at line 48 [2.976]

[2.2023]

    }
    fn save_page(&self) -> io::Result<()> {
        if let Some(page) = &self.page {
            match page.ready() {
                None => Err(io::Error::new(io::ErrorKind::NotFound, "No page")),
                Some(page) => match page {
                    Err(_) => Err(io::Error::new(io::ErrorKind::NotFound, "No page")),
                    Ok((gemini, _)) => match gemini.body_bytes() {
                        None => Err(io::Error::new(io::ErrorKind::NotFound, "No page")),
                        Some(page) => {
                            let url = Url::parse(self.url_history.last().unwrap()).unwrap();
                            let path = url.path_segments().unwrap();
                            let mut filename = path.last().unwrap();
                            if filename.is_empty() {
                                filename = "index.gmi";
                            }
                            let file = rfd::FileDialog::new().set_file_name(filename).save_file();
                            if let Some(file) = file {
                                let mut file = fs::File::create(file)?;
                                file.write_all(page)?;
                            }
                            Ok(())
                        }
                    },
                },
            }
        } else {
            Err(io::Error::new(io::ErrorKind::NotFound, "No page"))
        }
    }
    fn check_reload(&mut self, ctx: &egui::Context) {
        if self.reload {
            self.reload = false;
            let new_url = self.url_history.last().unwrap().clone();
            let new_url = match new_url.split_once("://") {
                Some(_) => new_url,
                None => "gemini://".to_string() + &new_url,
            };
            if let Ok(new_url) = Url::parse(&new_url) {
                match new_url.scheme() {
                    "gemini" => (),
                    _ => {
                        // TODO: Mime launch
                        self.url_history.pop();
                        self.reload = true;
                        return;
                    }
                }
                self.url_bar = new_url.as_str().to_string();
                let tls_config = self.tls_config.clone();
                let ctx = ctx.clone();
                let (sender, promise) = Promise::new();
                self.page = Some(promise);
                thread::spawn(move || {
                    sender.send((|| -> io::Result<(gemini::response::Response, Option<gemini::Builder>)> {
                                let addr = new_url.socket_addrs(|| match new_url.scheme() {
                                    "gemini" => Some(1965),
                                    _ => None,
                                })?[0];
                                let mut conn = rustls::ClientConnection::new(
                                    tls_config,
                                    new_url.host_str()
                                        .ok_or_else(|| io::Error::new(
                                            io::ErrorKind::InvalidInput,
                                            "No hostname",
                                        ))?
                                        .try_into()
                                        .map_err(|err| io::Error::new(io::ErrorKind::Other, err))?,
                                )
                                .map_err(|err| io::Error::new(io::ErrorKind::Other, err))?;
                                let mut sock = net::TcpStream::connect(addr)?;
                                let mut tls = rustls::Stream::new(&mut conn, &mut sock);
                                tls.write_all((new_url.as_str().to_string() + "\r\n").as_bytes())?;
                                let mut response = Vec::new();
                                tls.read_to_end(&mut response)?;
                                let gemini = gemini::parse::parse_response(response)
                                    .map_err(|err| io::Error::new(io::ErrorKind::Other, err))?;
                                // TODO: cleanup
                                let body =
                                    if let Some(mime_type) = gemini.header.mime_type() {
                                        if mime_type.split(';').next().unwrap() == "text/gemini" { 
                                            if let Some(body) = gemini.body_text() {
                                                Some(gemini::parse::parse_gemtext(body).map_err(|err| {
                                                    io::Error::new(io::ErrorKind::Other, err)
                                                })?)
                                            } else {
                                                None
                                            }
                                        } else {
                                            None
                                        }
                                    } else {
                                        None
                                    };
                                Ok((gemini, body))
                            })());
                    ctx.request_repaint();
                });
            }
        }

Replacement in src/main.rs at line 182 [2.976]

B:BD[2.2266] → [2.2266:2403]

        let Self {
            url,
            url_bar,
            reload,
            page,
            tls_config,
        } = self;

[2.2266]

[2.2403]

        egui::TopBottomPanel::top("top_panel").show(ctx, |ui| {
            ui.horizontal_centered(|ui| {
                use egui::FontFamily::Proportional;
                use egui::FontId;
                use egui::TextStyle::*;
                let mut style = &mut ui.style_mut();

Replacement in src/main.rs at line 190 [2.976]

B:BD[2.2404] → [2.2404:2554]

        egui::TopBottomPanel::top("top_panel").show(ctx, |ui| {
            egui::menu::bar(ui, |ui| {
                egui::warn_if_debug_build(ui);

[2.2404]

[2.2554]

                style.text_styles = [
                    (Body, FontId::new(20.0, Proportional)),
                    (Button, FontId::new(20.0, Proportional)),
                ]
                .into();

Replacement in src/main.rs at line 196 [2.976]

B:BD[2.2555] → [2.2555:2750]

                ui.menu_button("File", |ui| {
                    if ui.button("Quit").clicked() {
                        frame.quit();
                    }
                });
            });

[2.2555]

[2.2750]

                // History
                if ui
                    .add_enabled(self.url_history.len() > 1, egui::Button::new("⏴"))
                    .clicked()
                {
                    self.url_history.pop();
                    self.reload = true;
                }

Replacement in src/main.rs at line 205 [2.976]

B:BD[2.2751] → [2.2751:2849]

            ui.horizontal(|ui| {
                let response = ui.text_edit_singleline(url_bar);

[2.2751]

[2.2849]

                // URL entry
                let response = ui.add(
                    egui::TextEdit::singleline(&mut self.url_bar)
                        //.desired_width(f32::INFINITY)
                        .hint_text("Enter URL..."),
                );

Replacement in src/main.rs at line 213 [2.976]

B:BD[2.2937] → [2.2937:3023]

                    *reload = true;
                    url.push(url_bar.to_owned());

[2.2937]

[2.3023]

                    self.url_history.push(self.url_bar.to_owned());
                    self.reload = true;

Insertion in src/main.rs at line 216 [2.976]

[2.3041]


                // Menu
                ui.menu_button("☰", |ui| {
                    if ui.button("Save page").clicked() {
                        self.save_page().unwrap();
                    }
                })
                //});

Replacement in src/main.rs at line 231 [2.976]

B:BD[2.3243] → [2.3243:3290]

                    if let Some(page) = page {

[2.3243]

[2.3290]

                    if let Some(page) = &self.page {

Replacement in src/main.rs at line 241 [2.976]

B:BD[2.3769] → [2.3769:3901]

                                    url.push(gemini.header.meta().to_string());
                                    *reload = true;

[2.3769]

[2.3901]

                                    self.url_history.push(gemini.header.meta().to_string());
                                    self.reload = true;

Replacement in src/main.rs at line 263 [2.976]

B:BD[2.5166] → [2.5166:5259]

                                                        .button(name.as_ref().unwrap_or(to))

[2.5166]

[2.5259]

                                                        .button(name.as_ref().unwrap_or(&to))

Replacement in src/main.rs at line 266 [2.976]

B:BD[2.5380] → [2.5380:5477]

                                                        url.push(match Url::parse(to.as_str()) {

[2.5380]

[2.5477]

                                                        self.url_history.push(match Url::parse(to.as_str()) {

Replacement in src/main.rs at line 272 [2.976]

B:BD[2.5803] → [2.5803:6019]

                                                                let base = Url::parse(url.last().unwrap()).unwrap();
                                                                base.join(to).unwrap().to_string()

[2.5803]

[2.6019]

                                                                let base = Url::parse(self.url_history.last().unwrap()).unwrap();
                                                                base.join(&to).unwrap().to_string()

Replacement in src/main.rs at line 279 [2.976]

B:BD[2.6230] → [2.6230:6302]

                                                        *reload = true;

[2.6230]

[2.6302]

                                                        self.reload = true;

Replacement in src/main.rs at line 309 [2.976]

B:BD[2.8151] → [2.8151:8200]

                                        todo!();

[2.8151]

[2.8200]

                                        let mime = gemini.header.mime_type().unwrap();
                                                                                if mime.split("/").next().unwrap() == "text" {
                                            let body = gemini.body_text().unwrap();
                                            for line in body.split('\n') {
                                                ui.label(line);
                                            }
                                        } else {
                                            self.save_page().unwrap();
                                            self.url_history.pop();
                                            self.reload = true;
                                        }

Replacement in src/main.rs at line 350 [2.976]

B:BD[2.9384] → [2.9384:9434]

        if *reload {
            *reload = false;

[2.9384]

[2.9434]

        self.check_reload(ctx);

Deletion in src/main.rs at line 352 [2.976]

B:BD[2.9435] → [2.9435:13154]

            let new_url = url.last().unwrap().clone();
            let new_url = match new_url.split_once("://") {
                Some(_) => new_url,
                None => "gemini://".to_string() + &new_url,
            };
            if let Ok(new_url) = Url::parse(&new_url) {
                match new_url.scheme() {
                    "gemini" => (),
                    _ => {
                        // TODO: Mime launch
                        url.pop();
                        *reload = true;
                        return;
                    }
                }
                *url_bar = new_url.as_str().to_string();
                let ctx = ctx.clone();
                let tls_config = tls_config.clone();
                let (sender, promise) = Promise::new();
                *page = Some(promise);
                thread::spawn(move || {
                    sender.send((|| -> io::Result<(gemini::response::Response, Option<gemini::Builder>)> {
                                let addr = new_url.socket_addrs(|| match new_url.scheme() {
                                    "gemini" => Some(1965),
                                    _ => None,
                                })?[0];
                                let mut conn = rustls::ClientConnection::new(
                                    tls_config,
                                    new_url.host_str()
                                        .ok_or_else(|| io::Error::new(
                                            io::ErrorKind::InvalidInput,
                                            "No hostname",
                                        ))?
                                        .try_into()
                                        .map_err(|err| io::Error::new(io::ErrorKind::Other, err))?,
                                )
                                .map_err(|err| io::Error::new(io::ErrorKind::Other, err))?;
                                let mut sock = net::TcpStream::connect(addr)?;
                                let mut tls = rustls::Stream::new(&mut conn, &mut sock);
                                tls.write_all((new_url.as_str().to_string() + "\r\n").as_bytes())?;
                                let mut response = Vec::new();
                                tls.read_to_end(&mut response)?;
                                let gemini = gemini::parse::parse_response(response)
                                    .map_err(|err| io::Error::new(io::ErrorKind::Other, err))?;
                                // TODO: cleanup
                                let body =
                                    if let Some(mime_type) = gemini.header.mime_type() {
                                        if mime_type.split(';').next().unwrap() == "text/gemini" { 
                                            if let Some(body) = gemini.body_text() {
                                                Some(gemini::parse::parse_gemtext(body).map_err(|err| {
                                                    io::Error::new(io::ErrorKind::Other, err)
                                                })?)
                                            } else {
                                                None
                                            }
                                        } else {
                                            None
                                        }
                                    } else {
                                        None
                                    };
                                Ok((gemini, body))
                            })());
                    ctx.request_repaint();
                });
            }
        }

Insertion in Cargo.toml at line 9 [2.13597]
[2.13773]
[2.13773]
```
rfd = "*"
```