blockworx/

dialogs.rs

//! The platform's pickers, behind one seam.
//!
//! Every dialog the shell opens is opened through here, for two reasons. A
//! test must never reach a real one — a suite that did would stop with a
//! window open on someone's screen, waiting for a person — so a test build
//! answers from a queue it filled itself and opens nothing. And a flow's
//! *end* is then a value a test can supply, which is the only part of the
//! flow anything below the shell ever hears about.

use std::collections::VecDeque;

use blockworx_doc::block_model::Asset;

use crate::export::ExportPayload;

/// What a dialog answers with, once. The pickers run off the UI thread, so
/// every answer arrives through a channel the frame polls.
type Answer<T> = std::sync::mpsc::Receiver<T>;

/// The pickers, or the stand-in a test drives them through.
pub(crate) enum Dialogs {
    Native,
    Scripted(Scripted),
}

impl Default for Dialogs {
    /// A real build opens real dialogs; a test build cannot, so the choice is
    /// made here rather than at each of the twenty-odd places an `App` is
    /// built for a test — one of which would eventually forget.
    fn default() -> Self {
        if cfg!(test) {
            Dialogs::Scripted(Scripted::default())
        } else {
            Dialogs::Native
        }
    }
}

impl Dialogs {
    /// Pick artwork — for a block's icon, or for an image of its own.
    pub(crate) fn image(&mut self, ctx: &egui::Context) -> Answer<Option<Asset>> {
        match self {
            Dialogs::Native => crate::import::spawn_image_dialog(ctx),
            Dialogs::Scripted(scripted) => {
                scripted.asked.push(Asked::Image);
                answered(scripted.images.pop_front().flatten())
            }
        }
    }

    /// Pick a file to bring into the document (JSON / PNG / SVG).
    pub(crate) fn import(&mut self, ctx: &egui::Context) -> Answer<Option<(String, Vec<u8>)>> {
        match self {
            Dialogs::Native => crate::import::spawn_import_dialog(ctx),
            Dialogs::Scripted(scripted) => {
                scripted.asked.push(Asked::Import);
                answered(scripted.imports.pop_front().flatten())
            }
        }
    }

    /// Open `request`'s own dialog — a container to open, a place to save one.
    #[cfg(not(target_arch = "wasm32"))]
    pub(crate) fn file(
        &mut self,
        ctx: &egui::Context,
        request: crate::file::FileRequest,
    ) -> crate::file::PickReceiver {
        match self {
            Dialogs::Native => crate::file::spawn_file_dialog(ctx, request),
            Dialogs::Scripted(scripted) => {
                scripted.asked.push(Asked::File(request));
                answered(scripted.files.pop_front().flatten())
            }
        }
    }

    /// Write `payload` out, through the save dialog that names it.
    pub(crate) fn export(&mut self, ctx: &egui::Context, payload: ExportPayload) {
        match self {
            Dialogs::Native => crate::export::spawn_export(ctx, payload),
            Dialogs::Scripted(scripted) => {
                scripted.asked.push(Asked::Export(payload.name.clone()));
                scripted.exports.push_back(payload);
            }
        }
    }
}

/// What a flow the shell runs needs from around it: the frame's context, and
/// the pickers it opens through. The two travel together because every one of
/// them needs both — the picker to open, and the context to wake the canvas
/// when it answers.
pub(crate) struct Ask<'a> {
    pub ctx: &'a egui::Context,
    pub dialogs: &'a mut Dialogs,
}

impl Ask<'_> {
    pub(crate) fn image(&mut self) -> Answer<Option<Asset>> {
        self.dialogs.image(self.ctx)
    }

    pub(crate) fn import(&mut self) -> Answer<Option<(String, Vec<u8>)>> {
        self.dialogs.import(self.ctx)
    }

    #[cfg(not(target_arch = "wasm32"))]
    pub(crate) fn file(&mut self, request: crate::file::FileRequest) -> crate::file::PickReceiver {
        self.dialogs.file(self.ctx, request)
    }
}

/// One request a scripted run recorded. A cancel is not here: cancelling is
/// what an unanswered request does, and what it *means* is the shell's, so
/// there is nothing about it to record.
#[derive(Clone, PartialEq, Eq, Debug)]
pub(crate) enum Asked {
    Image,
    Import,
    #[cfg(not(target_arch = "wasm32"))]
    File(crate::file::FileRequest),
    /// The name the export would have been written under.
    Export(String),
}

/// The stand-in: it records what it was asked for and answers from what a test
/// queued, and an empty queue answers the way a cancelled dialog does.
#[derive(Default)]
pub(crate) struct Scripted {
    asked: Vec<Asked>,
    images: VecDeque<Option<Asset>>,
    imports: VecDeque<Option<(String, Vec<u8>)>>,
    #[cfg(not(target_arch = "wasm32"))]
    files: VecDeque<Option<crate::file::FilePick>>,
    /// What an export delivered here instead of to a file: a scripted run has
    /// no disk to write, and the bytes are what a test is about.
    exports: VecDeque<ExportPayload>,
}

/// A channel already holding its one answer, so the frame that polls it reads
/// the answer on the first poll rather than waiting for a thread.
fn answered<T>(value: T) -> Answer<T> {
    let (tx, rx) = std::sync::mpsc::channel();
    let _ = tx.send(value);
    rx
}

#[cfg(test)]
impl Dialogs {
    /// What the run has been asked to open, in order.
    pub(crate) fn asked(&self) -> &[Asked] {
        match self {
            Dialogs::Native => &[],
            Dialogs::Scripted(scripted) => &scripted.asked,
        }
    }

    /// What the next image pick answers with.
    pub(crate) fn answer_image(&mut self, asset: Option<Asset>) {
        self.scripted().images.push_back(asset);
    }

    /// What the next import answers with.
    pub(crate) fn answer_import(&mut self, file: Option<(String, Vec<u8>)>) {
        self.scripted().imports.push_back(file);
    }

    /// The next export this run was handed, in the order they arrived.
    pub(crate) fn exported(&mut self) -> Option<ExportPayload> {
        self.scripted().exports.pop_front()
    }

    /// What the next file dialog answers with.
    #[cfg(not(target_arch = "wasm32"))]
    pub(crate) fn answer_file(&mut self, pick: Option<crate::file::FilePick>) {
        self.scripted().files.push_back(pick);
    }

    fn scripted(&mut self) -> &mut Scripted {
        match self {
            Dialogs::Scripted(scripted) => scripted,
            Dialogs::Native => panic!("a test is driving the platform's own dialogs"),
        }
    }
}