wip

Author: prokopyl

examples/plugin_clack/src/audio.rs

@@ -3,7 +3,7 @@ use clack_plugin::prelude::*;
 
 pub struct ExamplePluginAudioProcessor;
 
-impl<'a> PluginAudioProcessor<'a, (), ExamplePluginMainThread> for ExamplePluginAudioProcessor {
+impl<'a> PluginAudioProcessor<'a, (), ExamplePluginMainThread<'a>> for ExamplePluginAudioProcessor {
     fn activate(
         _host: HostAudioProcessorHandle<'a>, _main_thread: &mut ExamplePluginMainThread,
         _shared: &'a (), _audio_config: PluginAudioConfiguration,

examples/plugin_clack/src/gui.rs

@@ -2,21 +2,22 @@ use crate::window_handler::OpenWindowExample;
 use crate::ExamplePluginMainThread;
 use baseview::dpi::*;
 use baseview::gl::GlConfig;
-use baseview::{WindowHandle, WindowOpenOptions, WindowSize};
+use baseview::host::{Host, HostCallbacks, HostMainThreadCaller};
+use baseview::{HandlerError, WindowHandle, WindowOpenOptions, WindowSize};
 use clack_extensions::gui::{
-    AspectRatioStrategy, GuiApiType, GuiConfiguration, GuiResizeHints, GuiSize, PluginGuiImpl,
-    Window as ClapWindow,
+    AspectRatioStrategy, GuiApiType, GuiConfiguration, GuiResizeHints, GuiSize, HostGui,
+    PluginGuiImpl, Window as ClapWindow,
 };
 use clack_plugin::plugin::PluginError;
-
+use clack_plugin::prelude::{HostMainThreadHandle, HostSharedHandle};
 #[allow(deprecated)]
 use raw_window_handle::HasRawWindowHandle;
 
 pub struct ExamplePluginGui {
     handle: WindowHandle,
 }
 
-impl PluginGuiImpl for ExamplePluginMainThread {
+impl PluginGuiImpl for ExamplePluginMainThread<'_> {
     fn is_api_supported(&mut self, configuration: GuiConfiguration) -> bool {
         !configuration.is_floating
             && Some(configuration.api_type) == GuiApiType::default_for_current_platform()
@@ -97,7 +98,17 @@ impl PluginGuiImpl for ExamplePluginMainThread {
             .with_gl_config(GlConfig::default())
             .with_parent(&parent);
 
-        let window = baseview::create_window(options, OpenWindowExample::new)?;
+        let mut host = Host::new().with_main_thread(unsafe {
+            MainThreadHandler { host: self.host.shared().with_arbitrary_lifetime() }
+        });
+
+        if let Some(gui) = self.host_gui {
+            host = host.with_callbacks(unsafe {
+                HostGuiCallbacks { ext: gui, host: self.host.with_arbitrary_lifetime() }
+            });
+        }
+
+        let window = baseview::create_window_with_host(options, OpenWindowExample::new, host)?;
 
         self.gui = Some(ExamplePluginGui { handle: window });
 
@@ -145,3 +156,30 @@ fn gui_size_to_window_size(size: GuiSize) -> Size {
         Size::Physical(PhysicalSize::new(size.width, size.height))
     }
 }
+
+struct MainThreadHandler {
+    host: HostSharedHandle<'static>,
+}
+
+impl HostMainThreadCaller for MainThreadHandler {
+    fn call_main_thread(&mut self) {
+        self.host.request_callback();
+    }
+}
+
+struct HostGuiCallbacks {
+    ext: HostGui,
+    host: HostMainThreadHandle<'static>,
+}
+
+impl HostCallbacks for HostGuiCallbacks {
+    fn resized(&mut self, new_size: WindowSize) -> Result<(), HandlerError> {
+        let size = window_size_to_gui_size(new_size);
+        self.ext.request_resize(&self.host, size.width, size.height)?;
+        Ok(())
+    }
+
+    fn destroyed(&mut self) {
+        self.ext.closed(&self.host, true);
+    }
+}

examples/plugin_clack/src/lib.rs

@@ -1,6 +1,6 @@
 use crate::audio::ExamplePluginAudioProcessor;
 use crate::gui::ExamplePluginGui;
-use clack_extensions::gui::PluginGui;
+use clack_extensions::gui::{HostGui, PluginGui};
 use clack_plugin::prelude::*;
 
 mod audio;
@@ -15,7 +15,7 @@ pub struct ExamplePlugin;
 impl Plugin for ExamplePlugin {
     type AudioProcessor<'a> = ExamplePluginAudioProcessor;
     type Shared<'a> = ();
-    type MainThread<'a> = ExamplePluginMainThread;
+    type MainThread<'a> = ExamplePluginMainThread<'a>;
 
     fn declare_extensions(builder: &mut PluginExtensions<Self>, _shared: Option<&()>) {
         builder.register::<PluginGui>();
@@ -35,19 +35,23 @@ impl DefaultPluginFactory for ExamplePlugin {
     }
 
     fn new_main_thread<'a>(
-        _host: HostMainThreadHandle<'a>, _shared: &'a Self::Shared<'a>,
+        host: HostMainThreadHandle<'a>, _shared: &'a Self::Shared<'a>,
     ) -> Result<Self::MainThread<'a>, PluginError> {
-        Ok(Self::MainThread { gui: None })
+        Ok(Self::MainThread { gui: None, host_gui: host.get_extension(), host })
     }
 }
 
 /// The data that belongs to the main thread of our plugin.
-pub struct ExamplePluginMainThread {
+pub struct ExamplePluginMainThread<'a> {
+    /// The host handle
+    host: HostMainThreadHandle<'a>,
+    // The host GUI extension handle
+    host_gui: Option<HostGui>,
     /// The plugin's GUI state and context
     gui: Option<ExamplePluginGui>,
 }
 
-impl<'a> PluginMainThread<'a, ()> for ExamplePluginMainThread {
+impl<'a> PluginMainThread<'a, ()> for ExamplePluginMainThread<'a> {
     fn on_main_thread(&mut self) {}
 }
 

src/host.rs

@@ -0,0 +1,37 @@
+use crate::{HandlerError, WindowSize};
+
+pub trait HostMainThreadCaller: Send + 'static {
+    fn call_main_thread(&mut self);
+}
+
+pub trait HostCallbacks: 'static {
+    fn resized(&mut self, new_size: WindowSize) -> Result<(), HandlerError>;
+    fn destroyed(&mut self);
+}
+
+pub struct Host {
+    pub(crate) main_thread: Option<Box<dyn HostMainThreadCaller>>,
+    pub(crate) callbacks: Option<Box<dyn HostCallbacks>>,
+}
+
+impl Default for Host {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Host {
+    pub fn new() -> Self {
+        Self { main_thread: None, callbacks: None }
+    }
+
+    pub fn with_main_thread(mut self, main_thread: impl HostMainThreadCaller) -> Self {
+        self.main_thread = Some(Box::new(main_thread));
+        self
+    }
+
+    pub fn with_callbacks(mut self, callbacks: impl HostCallbacks) -> Self {
+        self.callbacks = Some(Box::new(callbacks));
+        self
+    }
+}

src/lib.rs

@@ -3,6 +3,7 @@ mod context;
 mod error;
 mod event;
 mod handler;
+pub mod host;
 mod keyboard;
 mod mouse_cursor;
 mod tracing;

src/platform/x11/window_thread.rs

@@ -1,5 +1,6 @@
 use super::*;
 use crate::handler::WindowHandlerBuilder;
+use crate::host::Host;
 use crate::platform::x11::event_loop::EventLoop;
 use crate::platform::x11::window_shared::WindowInner;
 use crate::{WindowContext, WindowOpenOptions, WindowSize};
@@ -75,7 +76,7 @@ pub struct WindowThreadHandle {
 
 impl WindowThreadHandle {
     pub fn create_window(
-        options: WindowOpenOptions, handler: WindowHandlerBuilder,
+        options: WindowOpenOptions, handler: WindowHandlerBuilder, host: Host,
     ) -> Result<Self> {
         let (tx, rx) = result_channel();
         let shared = Arc::new(WindowThreadShared::new());
@@ -84,6 +85,7 @@ impl WindowThreadHandle {
 
         let join_handle = {
             let shared = shared.clone();
+            let main_thread_caller = host.main_thread;
 
             thread::spawn(move || {
                 let thread = match WindowThread::create(

src/window.rs

@@ -1,4 +1,5 @@
 use crate::handler::WindowHandlerBuilder;
+use crate::host::Host;
 use crate::platform;
 use crate::*;
 use dpi::{LogicalSize, PhysicalSize, Pixel, Size};
@@ -69,15 +70,28 @@ impl WindowHandle {
     pub fn is_open(&self) -> bool {
         self.window_handle.is_open()
     }
+
+    pub fn host_main_thread_callback(&mut self) {
+        todo!()
+    }
 }
 
 pub fn create_window<H: WindowHandler>(
     builder: WindowOpenOptions,
     handler: impl FnOnce(WindowContext) -> Result<H, HandlerError> + Send + 'static,
+) -> Result<WindowHandle, Error> {
+    create_window_with_host(builder, handler, None)
+}
+
+pub fn create_window_with_host<H: WindowHandler>(
+    builder: WindowOpenOptions,
+    handler: impl FnOnce(WindowContext) -> Result<H, HandlerError> + Send + 'static,
+    host: impl Into<Option<Host>>,
 ) -> Result<WindowHandle, Error> {
     Ok(WindowHandle::new(platform::WindowHandle::create_window(
         builder,
         WindowHandlerBuilder::new(handler),
+        host.into().unwrap_or_else(Host::default),
     )?))
 }