Introduce `baseview-core` crate for a common, more stable API for other crates to re-export

[prokopyl]

Currently, GUI framework integration crates (such as egui-baseview and iced-baseview) have to either wrap or re-implement a lot of baseview's types if they want to expose them in their public APIs, just to shield themselves from semver-incompatible baseview releases (even though the aforementioned APIs actually rarely change, compared to e.g. WindowHandler APIs).

This results in a lot of tedious and ultimately unnecessary code that those crates have to implement and maintain.

This is because the baseview crate currently acts as a bridge for two different sides: the GUI implementation/framework adapter side, and the plugin/plugin framework/host side.

We could create a new baseview-core (name TBD) crate that would expose the more stable utilities and APIs as traits for plugins to use directly, while leaving out the WindowHandler & co. APIs only for GUI implementations (and/or framework adapters) to use.

Ideally, plugin frameworks such as Nice-Plug could potentially even support spawning and managing any type of Window that implements baseview-core traits, making any-to-any compatibility between plugin frameworks and GUI frameworks possible.

[BillyDM]

Yeah, I like this idea! The main three things I need for nice-plug are NativeSize, HostCallbacks, and HostMainThreadCaller.

It would also be nice to have baseview::Window and baseview::Error, but it's fine if that's not possible yet. In nice-plug's EditorHandle trait, a lot of the methods are just re-calling methods on baseview::Window:

impl EditorHandle for EguiEditorHandle {
    type Window = baseview::Window;
    type Error = baseview::Error;

    fn run_until_closed(window: Self::Window) -> Result<(), Self::Error> {
        window.run_until_closed()
    }

    fn set_parent(
        &self,
        parent: ParentWindowHandle,
        window: &Self::Window,
    ) -> Result<(), Self::Error> {
        window.set_parent(&parent)
    }

    fn show(&self, window: &Self::Window) -> Result<(), Self::Error> {
        let res = window.show();

        // TODO: This might be a baseview bug. the `baseview::WindowEvent::Focused`
        // event does not always get called after `window.show()` is called. Either
        // that, or baseview needs to add a `baseview::WindowEvent::Shown` event.
        //
        // For now, we must manually trigger a redraw.
        self.repaint_notifier.request_repaint();

        res
    }

    fn hide(&self, window: &Self::Window) -> Result<(), Self::Error> {
        window.hide()
    }

    fn host_main_thread_callback(&self, window: &Self::Window) {
        window.host_main_thread_callback();
    }

    fn set_size(
        &self,
        new_size: NativeSize<u32>,
        window: &Self::Window,
    ) -> Result<(), Self::Error> {
        window.resize(new_size)
    }

    fn set_fallback_scale_factor(
        &self,
        scale_factor: f64,
        window: &Self::Window,
    ) -> Result<(), Self::Error> {
        window.suggest_fallback_scale_factor(scale_factor)
    }

    /// Return the closest supported size.
    fn adjust_size(
        &self,
        new_size: NativeSize<u32>,
        window: &Self::Window,
    ) -> Option<NativeSize<u32>> {
        let current_size = window.size();
        Some(self.resize_hint.adjust_size(
            new_size,
            NativeSize::from_logical_or_physical(current_size.logical, current_size.physical),
            current_size.scale_factor,
        ))
    }

    fn on_virtual_key_from_host(
        &self,
        _key_code: VirtualKeyCode,
        _is_down: bool,
        _modifiers: Modifiers,
    ) -> bool {
        // TODO
        false
    }

    fn state_changed(&self) {
        self.repaint_notifier.request_repaint();
    }

    fn param_value_changed(&self, _id: &str, _normalized_value: f32) {
        self.repaint_notifier.request_repaint();
    }

    fn param_modulation_changed(&self, _id: &str, _modulation_offset: f32) {
        self.repaint_notifier.request_repaint();
    }
}

One idea could be to have as stable baseview::WindowTrait, that way nice-plug could just hold on to a Box<dyn WindowTrait>.