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)

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 55-67)

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

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

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

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

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

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

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

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

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

        sender.post(MainMessage::EnabledClick);

        window.show();

        Self {
            window,
            enabled,
            b,
            s_label,
            s,
            e_label,
            e,
        }
    }

examples/test/widgets.rs (line 128)

    fn init(mut init: Self::Init<'_>, sender: &ComponentSender<Self>) -> Self {
        // let mut window = Child::<Window>::init(init);
        let mut window = init.window(sender);
        window.set_text("Widgets example");
        window.set_size(Size::new(800.0, 600.0));
        init! {
            canvas: Canvas = (&window),
            ulabel: Label = (&window) => {
                text: "Username:",
                halign: HAlign::Right,
            },
            plabel: Label = (&window) => {
                text: "Password:",
                halign: HAlign::Right,
            },
            uentry: Edit = (&window) => {
                text: "AAA",
            },
            pentry: Edit = (&window) => {
                text: "123456",
                password: true,
            },
            pcheck: CheckBox = (&window) => {
                text: "Show",
                checked: false,
            },
            combo: ComboBox = (&window),
            list: ObservableVec<String> = (()) => {
                // https://www.zhihu.com/question/23600507/answer/140640887
                items: [
                    "烫烫烫",
                    "昍昍昍",
                    "ﾌﾌﾌﾌﾌﾌ",
                    "쳌쳌쳌"
                ],
            },
            r1: RadioButton = (&window) => {
                text: "屯屯屯",
                checked: true,
            },
            r2: RadioButton = (&window) => {
                text: "锟斤拷",
            },
            r3: RadioButton = (&window) => {
                text: "╠╠╠"
            },
            push_button: Button = (&window) => {
                text: "Push",
            },
            pop_button: Button = (&window) => {
                text: "Pop",
            },
            show_button: Button = (&window) => {
                text: "Show",
            },
            progress: Progress = (&window) => {
                indeterminate: true,
            },
            mltext: TextBox = (&window) => {
            },
        }
        HANDLER.with_app(|a| mltext.set_text(&a.config().s));

        window.show();

        Self {
            window,
            ulabel,
            plabel,
            uentry,
            pentry,
            pcheck,
            canvas,
            combo,
            list,
            index: None,
            r1,
            r2,
            r3,
            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>