webkit6/auto/

input_method_context.rs

// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// from webkit-gir-files
// DO NOT EDIT

use crate::{InputHints, InputPurpose, ffi};
use glib::{
    object::ObjectType as _,
    prelude::*,
    signal::{SignalHandlerId, connect_raw},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    /// Base class for input method contexts.
    ///
    /// WebKitInputMethodContext defines the interface to implement WebKit input methods.
    /// The input methods are used by WebKit, when editable content is focused, to map from
    /// key events to Unicode character strings.
    ///
    /// An input method may consume multiple key events in sequence and finally
    /// output the composed result. This is called preediting, and an input method
    /// may provide feedback about this process by displaying the intermediate
    /// composition states as preedit text.
    ///
    /// This is an Abstract Base Class, you cannot instantiate it.
    ///
    /// ## Properties
    ///
    ///
    /// #### `input-hints`
    ///  The [`InputHints`][crate::InputHints] of the input associated with this context.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `input-purpose`
    ///  The [`InputPurpose`][crate::InputPurpose] of the input associated with this context.
    ///
    /// Readable | Writeable
    ///
    /// ## Signals
    ///
    ///
    /// #### `committed`
    ///  Emitted when a complete input sequence has been entered by the user.
    /// This can be a single character immediately after a key press or the
    /// final result of preediting.
    ///
    ///
    ///
    ///
    /// #### `delete-surrounding`
    ///  Emitted when the input method wants to delete the context surrounding the cursor.
    /// If `offset` is a negative value, it means a position before the cursor.
    ///
    ///
    ///
    ///
    /// #### `preedit-changed`
    ///  Emitted whenever the preedit sequence currently being entered has changed.
    /// It is also emitted at the end of a preedit sequence, in which case
    /// `webkit_input_method_context_get_preedit()` returns the empty string.
    ///
    ///
    ///
    ///
    /// #### `preedit-finished`
    ///  Emitted when a preediting sequence has been completed or canceled.
    ///
    ///
    ///
    ///
    /// #### `preedit-started`
    ///  Emitted when a new preediting sequence starts.
    ///
    ///
    ///
    /// # Implements
    ///
    /// [`InputMethodContextExt`][trait@crate::prelude::InputMethodContextExt]
    #[doc(alias = "WebKitInputMethodContext")]
    pub struct InputMethodContext(Object<ffi::WebKitInputMethodContext, ffi::WebKitInputMethodContextClass>);

    match fn {
        type_ => || ffi::webkit_input_method_context_get_type(),
    }
}

impl InputMethodContext {
    pub const NONE: Option<&'static InputMethodContext> = None;
}

/// Trait containing all [`struct@InputMethodContext`] methods.
///
/// # Implementors
///
/// [`InputMethodContext`][struct@crate::InputMethodContext]
pub trait InputMethodContextExt: IsA<InputMethodContext> + 'static {
    /// Allow `key_event` to be handled by the input method.
    ///
    /// If [`true`] is returned, then no further processing should be
    /// done for the key event.
    /// ## `key_event`
    /// the key event to filter
    ///
    /// # Returns
    ///
    /// [`true`] if the key event was handled, or [`false`] otherwise
    #[doc(alias = "webkit_input_method_context_filter_key_event")]
    fn filter_key_event(&self, key_event: impl AsRef<gdk::Event>) -> bool {
        unsafe {
            from_glib(ffi::webkit_input_method_context_filter_key_event(
                self.as_ref().to_glib_none().0,
                key_event.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Get the value of the [`input-hints`][struct@crate::InputMethodContext#input-hints] property.
    ///
    /// # Returns
    ///
    /// the [`InputHints`][crate::InputHints] of the input associated with `self`
    #[doc(alias = "webkit_input_method_context_get_input_hints")]
    #[doc(alias = "get_input_hints")]
    #[doc(alias = "input-hints")]
    fn input_hints(&self) -> InputHints {
        unsafe {
            from_glib(ffi::webkit_input_method_context_get_input_hints(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Get the value of the [`input-purpose`][struct@crate::InputMethodContext#input-purpose] property.
    ///
    /// # Returns
    ///
    /// the [`InputPurpose`][crate::InputPurpose] of the input associated with `self`
    #[doc(alias = "webkit_input_method_context_get_input_purpose")]
    #[doc(alias = "get_input_purpose")]
    #[doc(alias = "input-purpose")]
    fn input_purpose(&self) -> InputPurpose {
        unsafe {
            from_glib(ffi::webkit_input_method_context_get_input_purpose(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    //#[doc(alias = "webkit_input_method_context_get_preedit")]
    //#[doc(alias = "get_preedit")]
    //fn preedit(&self, underlines: /*Unimplemented*/Vec<InputMethodUnderline>) -> (Option<glib::GString>, u32) {
    //    unsafe { TODO: call ffi:webkit_input_method_context_get_preedit() }
    //}

    /// Notify `self` that cursor area changed in input associated.
    /// ## `x`
    /// the x coordinate of cursor location
    /// ## `y`
    /// the y coordinate of cursor location
    /// ## `width`
    /// the width of cursor area
    /// ## `height`
    /// the height of cursor area
    #[doc(alias = "webkit_input_method_context_notify_cursor_area")]
    fn notify_cursor_area(&self, x: i32, y: i32, width: i32, height: i32) {
        unsafe {
            ffi::webkit_input_method_context_notify_cursor_area(
                self.as_ref().to_glib_none().0,
                x,
                y,
                width,
                height,
            );
        }
    }

    /// Notify `self` that input associated has gained focus.
    #[doc(alias = "webkit_input_method_context_notify_focus_in")]
    fn notify_focus_in(&self) {
        unsafe {
            ffi::webkit_input_method_context_notify_focus_in(self.as_ref().to_glib_none().0);
        }
    }

    /// Notify `self` that input associated has lost focus.
    #[doc(alias = "webkit_input_method_context_notify_focus_out")]
    fn notify_focus_out(&self) {
        unsafe {
            ffi::webkit_input_method_context_notify_focus_out(self.as_ref().to_glib_none().0);
        }
    }

    /// Notify `self` that the context surrounding the cursor has changed.
    ///
    /// If there's no selection `selection_index` is the same as `cursor_index`.
    /// ## `text`
    /// text surrounding the insertion point
    /// ## `length`
    /// the length of `text`, or -1 if `text` is nul-terminated
    /// ## `cursor_index`
    /// the byte index of the insertion cursor within `text`.
    /// ## `selection_index`
    /// the byte index of the selection cursor within `text`.
    #[doc(alias = "webkit_input_method_context_notify_surrounding")]
    fn notify_surrounding(&self, text: &str, cursor_index: u32, selection_index: u32) {
        let length = text.len() as _;
        unsafe {
            ffi::webkit_input_method_context_notify_surrounding(
                self.as_ref().to_glib_none().0,
                text.to_glib_none().0,
                length,
                cursor_index,
                selection_index,
            );
        }
    }

    /// Reset the `self`.
    ///
    /// This will typically cause the input to clear the preedit state.
    #[doc(alias = "webkit_input_method_context_reset")]
    fn reset(&self) {
        unsafe {
            ffi::webkit_input_method_context_reset(self.as_ref().to_glib_none().0);
        }
    }

    /// Set whether `self` should enable preedit to display feedback.
    /// ## `enabled`
    /// whether to enable preedit
    #[doc(alias = "webkit_input_method_context_set_enable_preedit")]
    fn set_enable_preedit(&self, enabled: bool) {
        unsafe {
            ffi::webkit_input_method_context_set_enable_preedit(
                self.as_ref().to_glib_none().0,
                enabled.into_glib(),
            );
        }
    }

    /// Set the value of the [`input-hints`][struct@crate::InputMethodContext#input-hints] property.
    /// ## `hints`
    /// a [`InputHints`][crate::InputHints]
    #[doc(alias = "webkit_input_method_context_set_input_hints")]
    #[doc(alias = "input-hints")]
    fn set_input_hints(&self, hints: InputHints) {
        unsafe {
            ffi::webkit_input_method_context_set_input_hints(
                self.as_ref().to_glib_none().0,
                hints.into_glib(),
            );
        }
    }

    /// Set the value of the [`input-purpose`][struct@crate::InputMethodContext#input-purpose] property.
    /// ## `purpose`
    /// a [`InputPurpose`][crate::InputPurpose]
    #[doc(alias = "webkit_input_method_context_set_input_purpose")]
    #[doc(alias = "input-purpose")]
    fn set_input_purpose(&self, purpose: InputPurpose) {
        unsafe {
            ffi::webkit_input_method_context_set_input_purpose(
                self.as_ref().to_glib_none().0,
                purpose.into_glib(),
            );
        }
    }

    /// Emitted when a complete input sequence has been entered by the user.
    /// This can be a single character immediately after a key press or the
    /// final result of preediting.
    /// ## `text`
    /// the string result
    #[doc(alias = "committed")]
    fn connect_committed<F: Fn(&Self, &str) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn committed_trampoline<
            P: IsA<InputMethodContext>,
            F: Fn(&P, &str) + 'static,
        >(
            this: *mut ffi::WebKitInputMethodContext,
            text: *mut std::ffi::c_char,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    InputMethodContext::from_glib_borrow(this).unsafe_cast_ref(),
                    &glib::GString::from_glib_borrow(text),
                )
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"committed".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    committed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when the input method wants to delete the context surrounding the cursor.
    /// If `offset` is a negative value, it means a position before the cursor.
    /// ## `offset`
    /// the character offset from the cursor position of the text to be deleted.
    /// ## `n_chars`
    /// the number of characters to be deleted
    #[doc(alias = "delete-surrounding")]
    fn connect_delete_surrounding<F: Fn(&Self, i32, u32) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn delete_surrounding_trampoline<
            P: IsA<InputMethodContext>,
            F: Fn(&P, i32, u32) + 'static,
        >(
            this: *mut ffi::WebKitInputMethodContext,
            offset: std::ffi::c_int,
            n_chars: std::ffi::c_uint,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    InputMethodContext::from_glib_borrow(this).unsafe_cast_ref(),
                    offset,
                    n_chars,
                )
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"delete-surrounding".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    delete_surrounding_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted whenever the preedit sequence currently being entered has changed.
    /// It is also emitted at the end of a preedit sequence, in which case
    /// `webkit_input_method_context_get_preedit()` returns the empty string.
    #[doc(alias = "preedit-changed")]
    fn connect_preedit_changed<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn preedit_changed_trampoline<
            P: IsA<InputMethodContext>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::WebKitInputMethodContext,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(InputMethodContext::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"preedit-changed".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    preedit_changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when a preediting sequence has been completed or canceled.
    #[doc(alias = "preedit-finished")]
    fn connect_preedit_finished<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn preedit_finished_trampoline<
            P: IsA<InputMethodContext>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::WebKitInputMethodContext,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(InputMethodContext::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"preedit-finished".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    preedit_finished_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when a new preediting sequence starts.
    #[doc(alias = "preedit-started")]
    fn connect_preedit_started<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn preedit_started_trampoline<
            P: IsA<InputMethodContext>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::WebKitInputMethodContext,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(InputMethodContext::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"preedit-started".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    preedit_started_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "input-hints")]
    fn connect_input_hints_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_input_hints_trampoline<
            P: IsA<InputMethodContext>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::WebKitInputMethodContext,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(InputMethodContext::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::input-hints".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_input_hints_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "input-purpose")]
    fn connect_input_purpose_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_input_purpose_trampoline<
            P: IsA<InputMethodContext>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::WebKitInputMethodContext,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(InputMethodContext::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::input-purpose".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_input_purpose_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl<O: IsA<InputMethodContext>> InputMethodContextExt for O {}