Struct PluginHandler 

pub struct PluginHandler<A: PluginApp> { /* private fields */ }

Example

PluginHandler::builder()
    .name("Test Plugin")
    .description("A test plugin for Everything")
    .author("Chaoses-Ib")
    .version("0.1.0")
    .link("https://github.com/Chaoses-Ib/IbEverythingLib")
    .options_pages(vec![
        OptionsPage::builder()
            .name("Test Plugin")
            .load(ui::winio::spawn::<options::MainModel>)
            .build(),
    ])
    .build()

Design

• Config may be accessed from multiple threads, and options pages need to modify it. To avoid race conditions, either config is cloned when modifying, and then PluginApp is reloaded with it, i.e. [arc_swap::ArcSwap]; or PluginApp is shutdown before modifying and then restarted.
• User defined static to work around generic static limit.
  • Interior mutability to make it easy to use with static. But UnsafeCell to avoid cost.

Config lifetime:

• May be set with PluginHandler::builder() (as default value)
• May be loaded when sys::EVERYTHING_PLUGIN_PM_START
• Be read when start
• Be read when loading (and rendering) options pages (sys::EVERYTHING_PLUGIN_PM_LOAD_OPTIONS_PAGE)
• Be written/applied when sys::EVERYTHING_PLUGIN_PM_SAVE_OPTIONS_PAGE, zero, one or multiple times
  • TODO: Defer
• Be saved when sys::EVERYTHING_PLUGIN_PM_SAVE_SETTINGS (can occur without prior sys::EVERYTHING_PLUGIN_PM_SAVE_OPTIONS_PAGE)

Implementations

impl<A: PluginApp> PluginHandler<A>

pub fn get_language_name(&self) -> String

impl<A: PluginApp> PluginHandler<A>

pub fn load_settings(&self, data: *mut c_void) -> Option<A::Config>

pub fn save_settings(&self, data: *mut c_void) -> *mut c_void

impl<A: PluginApp> PluginHandler<A>

pub fn add_options_pages(&self, data: *mut c_void) -> *mut c_void

pub fn load_options_page(&self, data: *mut c_void) -> *mut c_void

Evertyhing only loads a options page when the user selects it

TODO: tooltip_hwnd

pub fn load_options_page_winio<'a, T: OptionsPageComponent<'a>>( &self, data: *mut c_void, ) -> *mut c_void

Available on crate feature winio only.

pub fn save_options_page(&self, data: *mut c_void) -> *mut c_void

pub fn get_options_page_minmax(&self, _data: *mut c_void) -> *mut c_void

pub fn size_options_page(&self, _data: *mut c_void) -> *mut c_void

pub fn options_page_proc(&self, data: *mut c_void) -> *mut c_void

pub fn kill_options_page(&self, data: *mut c_void) -> *mut c_void

impl<A: PluginApp> PluginHandler<A>

pub fn builder() -> PluginHandlerBuilder<A>

Create an instance of PluginHandler using the builder syntax

impl<A: PluginApp> PluginHandler<A>

pub fn init_start(&self)

Panics if already initialized.

pub fn init_start_with_config(&self, config: A::Config)

Panics if already initialized.

pub fn stop_kill(&self)

Panics if not initialized or already stopped.

pub fn get_host(&self) -> Option<&PluginHost>

None before handling EVERYTHING_PLUGIN_PM_INIT

pub fn host(&self) -> &PluginHost

Not available before handling EVERYTHING_PLUGIN_PM_INIT

pub fn handle_init_i18n(_msg: u32, _data: *mut c_void)

Should be called before PluginHandler is created, as some fields may depend on the locale.

Already called in the plugin_main! macro. (Requiring manually calling is a footgun: IbEverythingExt #100)

pub fn handle(&self, msg: u32, data: *mut c_void) -> *mut c_void

You shouldn’t and unlikely need to call this function from multiple threads.

pub fn instance_name(&self) -> Option<&str>

pub unsafe fn app(&self) -> &A

Not available during saving config and recreated afterwards. Use Self::with_app instead when possible.

pub fn with_app<T>(&self, f: impl FnOnce(&A) -> T) -> T

Not available during saving config.

Examples found in repository

examples/options/options.rs (lines 58-70)

    async fn init(
        mut init: Self::Init<'_>,
        sender: &ComponentSender<Self>,
    ) -> Result<Self, Self::Error> {
        let mut window = init.window(sender).await?;
        // window.set_size(Size::new(800.0, 600.0));

        let mut enabled = Child::<CheckBox>::init(&window).await?;
        enabled.set_text("Enable");

        let mut b = Child::<CheckBox>::init(&window).await?;
        b.set_text("Switch");

        let mut e_label = Child::<Label>::init(&window).await?;
        e_label.set_text("Mode:");
        let mut e = Child::<ComboBox>::init(&window).await?;
        e.insert(0, "A");
        e.insert(1, "B");

        let mut s_label = Child::<Label>::init(&window).await?;
        s_label.set_text("Message:");
        let mut s = Child::<Edit>::init(&window).await?;

        HANDLER.with_app(|a| {
            let config = a.config();

            enabled.set_checked(config.enabled);
            b.set_checked(config.b);

            e.set_selection(match config.e {
                Mode::A => 0,
                Mode::B => 1,
            });

            s.set_text(&config.s);
        });

        sender.post(MainMessage::EnabledClick);

        window.show();

        Ok(Self {
            window,
            enabled,
            b,
            s_label,
            s,
            e_label,
            e,
        })
    }

examples/test/widgets.rs (line 120)

    async fn init(
        mut init: Self::Init<'_>,
        sender: &ComponentSender<Self>,
    ) -> Result<Self, Self::Error> {
        // let mut window = Child::<Window>::init(init);
        let mut window = init.window(sender).await?;
        // window.set_text("Widgets example");
        window.set_size(Size::new(800.0, 600.0));

        let canvas = Child::<Canvas>::init(&window).await?;
        let mut ulabel = Child::<Label>::init(&window).await?;
        ulabel.set_text("Username:");
        ulabel.set_halign(HAlign::Right);
        let mut plabel = Child::<Label>::init(&window).await?;
        plabel.set_text("Password:");
        plabel.set_halign(HAlign::Right);
        let mut uentry = Child::<Edit>::init(&window).await?;
        uentry.set_text("AAA");
        let mut pentry = Child::<Edit>::init(&window).await?;
        pentry.set_text("123456");
        pentry.set_password(true);
        let mut pcheck = Child::<CheckBox>::init(&window).await?;
        pcheck.set_text("Show");
        pcheck.set_checked(false);
        let combo = Child::<ComboBox>::init(&window).await?;
        let mut list = Child::<ObservableVec<String>>::init(Vec::new())
            .await
            .unwrap();
        // https://www.zhihu.com/question/23600507/answer/140640887
        list.push("烫烫烫".to_string());
        list.push("昍昍昍".to_string());
        list.push("ﾌﾌﾌﾌﾌﾌ".to_string());
        list.push("쳌쳌쳌".to_string());
        let mut r1 = Child::<RadioButton>::init(&window).await?;
        r1.set_text("屯屯屯");
        r1.set_checked(true);
        let mut r2 = Child::<RadioButton>::init(&window).await?;
        r2.set_text("锟斤拷");
        let mut r3 = Child::<RadioButton>::init(&window).await?;
        r3.set_text("╠╠╠");
        // Initialize radio group with the radio buttons
        let radio_group = Child::<RadioButtonGroup>::init(vec![r1, r2, r3]).await?;

        let mut push_button = Child::<Button>::init(&window).await?;
        push_button.set_text("Push");
        let mut pop_button = Child::<Button>::init(&window).await?;
        pop_button.set_text("Pop");
        let mut show_button = Child::<Button>::init(&window).await?;
        show_button.set_text("Show");
        let mut progress = Child::<Progress>::init(&window).await?;
        progress.set_indeterminate(true);
        let mut mltext = Child::<TextBox>::init(&window).await?;
        HANDLER.with_app(|a| mltext.set_text(&a.config().s));

        window.show();

        Ok(Self {
            window,
            ulabel,
            plabel,
            uentry,
            pentry,
            pcheck,
            canvas,
            combo,
            list,
            index: None,
            radio_group,
            rindex: 0,
            push_button,
            pop_button,
            show_button,
            progress,
            mltext,
        })
    }

Trait Implementations

impl<A: PluginApp> Send for PluginHandler<A>

impl<A: PluginApp> Sync for PluginHandler<A>