Struct Sioul 

#[repr(C)]
pub struct Sioul {
    _private: Opaque,
}

The C++ type for the QObject SioulRust

Use this type when referring to the QObject as a pointer

See the book for more information: https://kdab.github.io/cxx-qt/book/concepts/generated_qobject.html

Fields

_private: Opaque

Implementations

impl Sioul

pub fn porch_changed(self: Pin<&mut Self>)

Notify for the Q_PROPERTY

pub fn budgets_changed(self: Pin<&mut Self>)

Notify for the Q_PROPERTY

pub fn accounts_changed(self: Pin<&mut Self>)

Notify for the Q_PROPERTY

pub fn blocked_changed(self: Pin<&mut Self>)

Notify for the Q_PROPERTY

pub fn status_changed(self: Pin<&mut Self>)

Notify for the Q_PROPERTY

pub fn busy_changed(self: Pin<&mut Self>)

Notify for the Q_PROPERTY

pub fn found_changed(self: Pin<&mut Self>)

Notify for the Q_PROPERTY

pub fn scouted_changed(self: Pin<&mut Self>)

Notify for the Q_PROPERTY

pub fn scouting_changed(self: Pin<&mut Self>)

Notify for the Q_PROPERTY

pub fn form_error_changed(self: Pin<&mut Self>)

Notify for the Q_PROPERTY

pub fn form_busy_changed(self: Pin<&mut Self>)

Notify for the Q_PROPERTY

pub fn mail_accounts_changed(self: Pin<&mut Self>)

Notify for the Q_PROPERTY

pub fn mail_folder_changed(self: Pin<&mut Self>)

Notify for the Q_PROPERTY

pub fn drafts_changed(self: Pin<&mut Self>)

Notify for the Q_PROPERTY

pub fn mail_search_changed(self: Pin<&mut Self>)

Notify for the Q_PROPERTY

pub fn undo_line_changed(self: Pin<&mut Self>)

Notify for the Q_PROPERTY

pub fn contacts_changed(self: Pin<&mut Self>)

Notify for the Q_PROPERTY

pub fn duplicates_changed(self: Pin<&mut Self>)

Notify for the Q_PROPERTY

pub fn agenda_changed(self: Pin<&mut Self>)

Notify for the Q_PROPERTY

pub fn overlaps_changed(self: Pin<&mut Self>)

Notify for the Q_PROPERTY

pub fn health_view_changed(self: Pin<&mut Self>)

Notify for the Q_PROPERTY

pub fn missed_view_changed(self: Pin<&mut Self>)

Notify for the Q_PROPERTY

pub fn needs_view_changed(self: Pin<&mut Self>)

Notify for the Q_PROPERTY

pub fn tasks_changed(self: Pin<&mut Self>)

Notify for the Q_PROPERTY

pub fn notes_changed(self: Pin<&mut Self>)

Notify for the Q_PROPERTY

pub fn focus_session_changed(self: Pin<&mut Self>)

Notify for the Q_PROPERTY

pub fn reading_changed(self: Pin<&mut Self>)

Notify for the Q_PROPERTY

pub fn realtime_changed(self: Pin<&mut Self>)

Notify for the Q_PROPERTY

pub fn away_changed(self: Pin<&mut Self>)

Notify for the Q_PROPERTY

pub fn mode_changed(self: Pin<&mut Self>)

Notify for the Q_PROPERTY

pub fn forecast_changed(self: Pin<&mut Self>)

Notify for the Q_PROPERTY

pub fn places_found_changed(self: Pin<&mut Self>)

Notify for the Q_PROPERTY

pub fn copy_requested(self: Pin<&mut Self>, text: QString)

The notification’s “copy” button was pressed.

pub fn account_added(self: Pin<&mut Self>)

An account was added: the form can be emptied.

pub fn account_password_done( self: Pin<&mut Self>, id: QString, problem: QString, )

An account’s password given here: kept (problem empty), else why not.

pub fn letters_changed(self: Pin<&mut Self>)

Paper letters were read: the Porch shows them again.

pub fn task_done(self: Pin<&mut Self>, uid: QString)

A task just done, whichever way (a list, its panel, the focus window): the status line offers “How was it?”, quietly.

pub fn shared_in(self: Pin<&mut Self>, stores: QString)

Your other devices’ changes written here by the sharing: the stores written, one per line (“data/time/”, “state/health-state.toml”…), for the pages that show them to read again.

pub fn share_listed(self: Pin<&mut Self>, versions: QString)

The versions kept, listed (share_history), as JSON.

pub fn share_put_back_done(self: Pin<&mut Self>, problem: QString)

A version put back (share_put_back): what went wrong, else “”.

pub fn share_estimated(self: Pin<&mut Self>, estimate: QString)

What switching Notes or Papers on would send (share_estimate), as JSON {“part”, “text”}.

pub fn spam_changed(self: Pin<&mut Self>, status: QString)

The spam filter’s training moved on, or ended: its state, as spam_status gives it.

pub fn mail_filters_found(self: Pin<&mut Self>, found: QString)

What “Try it” or the mail filters’ preview found, as JSON {kind, text, lines, count}.

pub fn message_read( self: Pin<&mut Self>, key: QString, reading: QString, invitation: QString, )

A message read for the reading pane (read_message): its key, the message laid out for reading as JSON (view::MessageView; empty if it cannot be read), and the invitation it carries (JSON; empty when none).

pub fn share_started(self: Pin<&mut Self>, problem: QString)

Sharing through a folder Sioul keeps in step with a server itself (start_sharing_on_server): “” when it started, else why not.

pub fn reminder_opened( self: Pin<&mut Self>, kind: QString, uri: QString, key: QString, )

A reminder’s “Open” was pressed: what it is about (“task”, “event”, “budget”), shown.

pub fn open_url(self: Pin<&mut Self>, url: QString)

An attachment passed the antivirus: the desktop opens it.

pub fn scan_unavailable( self: Pin<&mut Self>, key: QString, index: i32, what: i32, name: QString, hint: QString, big: bool, )

No antivirus answered, or the file is larger than it scans (big): the window asks before opening or saving, with how to install one.

pub fn paper_kept( self: Pin<&mut Self>, file: QString, title: QString, kind: QString, )

An attachment was kept in the papers wallet: the form, to say what it is.

pub fn compose_requested(self: Pin<&mut Self>, id: QString)

A draft’s window opens again: “Undo” after sending or discarding. Also a new draft handed by another application (outside).

pub fn draft_files_arrived( self: Pin<&mut Self>, id: QString, line: QString, problem: bool, )

Files shared from another application came for draft id (outside): its window reads its attachments again and says line, a problem when some did not come.

pub fn keys_changed(self: Pin<&mut Self>)

Keys were found or made: windows showing them read them again.

pub fn security_key_changed( self: Pin<&mut Self>, context: QString, state: QString, )

What a security key’s band shows now, as JSON {state, line, tries, warm, action}: for context, a draft’s id, a message’s key, or “setup”.

pub fn links_changed(self: Pin<&mut Self>)

A tie was made or undone: what shows ties reads them again.

pub fn places_changed(self: Pin<&mut Self>)

Addresses were placed on the map.

pub fn sites_changed(self: Pin<&mut Self>)

A site notified something, or was seen.

pub fn bitwarden_found(self: Pin<&mut Self>, ticket: i32, found: QString)

A large vault’s search, done off the window’s thread: its ticket and its answer (bitwarden_search).

pub fn bitwarden_answered(self: Pin<&mut Self>, ticket: i32, answer: QString)

Bitwarden’s server answered, off the window’s thread: the ticket an unlock, a passkey or a code’s sending gave, and its answer.

pub fn phone_account_chosen(self: Pin<&mut Self>, name: QString, kind: QString)

An account chosen among the phone’s: its name (an address, usually) and its kind (“com.google”, “e.foundation.webdav.eelo”…); both empty when none was.

impl Sioul

pub fn porch(&self) -> &QString

Getter for the Q_PROPERTY porch

impl Sioul

pub fn set_porch(self: Pin<&mut Self>, value: QString)

Setter for the Q_PROPERTY porch

impl Sioul

pub fn budgets(&self) -> &QString

Getter for the Q_PROPERTY budgets

impl Sioul

pub fn set_budgets(self: Pin<&mut Self>, value: QString)

Setter for the Q_PROPERTY budgets

impl Sioul

pub fn accounts(&self) -> &QString

Getter for the Q_PROPERTY accounts

impl Sioul

pub fn set_accounts(self: Pin<&mut Self>, value: QString)

Setter for the Q_PROPERTY accounts

impl Sioul

pub fn blocked(&self) -> &QString

Getter for the Q_PROPERTY blocked

impl Sioul

pub fn set_blocked(self: Pin<&mut Self>, value: QString)

Setter for the Q_PROPERTY blocked

impl Sioul

pub fn status(&self) -> &QString

Getter for the Q_PROPERTY status

impl Sioul

pub fn set_status(self: Pin<&mut Self>, value: QString)

Setter for the Q_PROPERTY status

impl Sioul

pub fn busy(&self) -> &bool

Getter for the Q_PROPERTY busy

impl Sioul

pub fn set_busy(self: Pin<&mut Self>, value: bool)

Setter for the Q_PROPERTY busy

impl Sioul

pub fn found(&self) -> &QString

Getter for the Q_PROPERTY found

impl Sioul

pub fn set_found(self: Pin<&mut Self>, value: QString)

Setter for the Q_PROPERTY found

impl Sioul

pub fn scouted(&self) -> &QString

Getter for the Q_PROPERTY scouted

impl Sioul

pub fn set_scouted(self: Pin<&mut Self>, value: QString)

Setter for the Q_PROPERTY scouted

impl Sioul

pub fn scouting(&self) -> &bool

Getter for the Q_PROPERTY scouting

impl Sioul

pub fn set_scouting(self: Pin<&mut Self>, value: bool)

Setter for the Q_PROPERTY scouting

impl Sioul

pub fn form_error(&self) -> &QString

Getter for the Q_PROPERTY form_error

impl Sioul

pub fn set_form_error(self: Pin<&mut Self>, value: QString)

Setter for the Q_PROPERTY form_error

impl Sioul

pub fn form_busy(&self) -> &bool

Getter for the Q_PROPERTY form_busy

impl Sioul

pub fn set_form_busy(self: Pin<&mut Self>, value: bool)

Setter for the Q_PROPERTY form_busy

impl Sioul

pub fn mail_accounts(&self) -> &QString

Getter for the Q_PROPERTY mail_accounts

impl Sioul

pub fn set_mail_accounts(self: Pin<&mut Self>, value: QString)

Setter for the Q_PROPERTY mail_accounts

impl Sioul

pub fn mail_folder(&self) -> &QString

Getter for the Q_PROPERTY mail_folder

impl Sioul

pub fn set_mail_folder(self: Pin<&mut Self>, value: QString)

Setter for the Q_PROPERTY mail_folder

impl Sioul

pub fn drafts(&self) -> &QString

Getter for the Q_PROPERTY drafts

impl Sioul

pub fn set_drafts(self: Pin<&mut Self>, value: QString)

Setter for the Q_PROPERTY drafts

impl Sioul

pub fn mail_search(&self) -> &QString

Getter for the Q_PROPERTY mail_search

impl Sioul

pub fn set_mail_search(self: Pin<&mut Self>, value: QString)

Setter for the Q_PROPERTY mail_search

impl Sioul

pub fn undo_line(&self) -> &QString

Getter for the Q_PROPERTY undo_line

impl Sioul

pub fn set_undo_line(self: Pin<&mut Self>, value: QString)

Setter for the Q_PROPERTY undo_line

impl Sioul

pub fn contacts(&self) -> &QString

Getter for the Q_PROPERTY contacts

impl Sioul

pub fn set_contacts(self: Pin<&mut Self>, value: QString)

Setter for the Q_PROPERTY contacts

impl Sioul

pub fn duplicates(&self) -> &QString

Getter for the Q_PROPERTY duplicates

impl Sioul

pub fn set_duplicates(self: Pin<&mut Self>, value: QString)

Setter for the Q_PROPERTY duplicates

impl Sioul

pub fn agenda(&self) -> &QString

Getter for the Q_PROPERTY agenda

impl Sioul

pub fn set_agenda(self: Pin<&mut Self>, value: QString)

Setter for the Q_PROPERTY agenda

impl Sioul

pub fn overlaps(&self) -> &QString

Getter for the Q_PROPERTY overlaps

impl Sioul

pub fn set_overlaps(self: Pin<&mut Self>, value: QString)

Setter for the Q_PROPERTY overlaps

impl Sioul

pub fn health_view(&self) -> &QString

Getter for the Q_PROPERTY health_view

impl Sioul

pub fn set_health_view(self: Pin<&mut Self>, value: QString)

Setter for the Q_PROPERTY health_view

impl Sioul

pub fn missed_view(&self) -> &QString

Getter for the Q_PROPERTY missed_view

impl Sioul

pub fn set_missed_view(self: Pin<&mut Self>, value: QString)

Setter for the Q_PROPERTY missed_view

impl Sioul

pub fn needs_view(&self) -> &QString

Getter for the Q_PROPERTY needs_view

impl Sioul

pub fn set_needs_view(self: Pin<&mut Self>, value: QString)

Setter for the Q_PROPERTY needs_view

impl Sioul

pub fn tasks(&self) -> &QString

Getter for the Q_PROPERTY tasks

impl Sioul

pub fn set_tasks(self: Pin<&mut Self>, value: QString)

Setter for the Q_PROPERTY tasks

impl Sioul

pub fn notes(&self) -> &QString

Getter for the Q_PROPERTY notes

impl Sioul

pub fn set_notes(self: Pin<&mut Self>, value: QString)

Setter for the Q_PROPERTY notes

impl Sioul

pub fn focus_session(&self) -> &QString

Getter for the Q_PROPERTY focus_session

impl Sioul

pub fn set_focus_session(self: Pin<&mut Self>, value: QString)

Setter for the Q_PROPERTY focus_session

impl Sioul

pub fn reading(&self) -> &QString

Getter for the Q_PROPERTY reading

impl Sioul

pub fn set_reading(self: Pin<&mut Self>, value: QString)

Setter for the Q_PROPERTY reading

impl Sioul

pub fn realtime(&self) -> &bool

Getter for the Q_PROPERTY realtime

impl Sioul

pub fn set_realtime(self: Pin<&mut Self>, value: bool)

Setter for the Q_PROPERTY realtime

impl Sioul

pub fn away(&self) -> &bool

Getter for the Q_PROPERTY away

impl Sioul

pub fn set_away(self: Pin<&mut Self>, value: bool)

Setter for the Q_PROPERTY away

impl Sioul

pub fn mode(&self) -> &QString

Getter for the Q_PROPERTY mode

impl Sioul

pub fn set_mode(self: Pin<&mut Self>, value: QString)

Setter for the Q_PROPERTY mode

impl Sioul

pub fn forecast(&self) -> &QString

Getter for the Q_PROPERTY forecast

impl Sioul

pub fn set_forecast(self: Pin<&mut Self>, value: QString)

Setter for the Q_PROPERTY forecast

impl Sioul

pub fn places_found(&self) -> &QString

Getter for the Q_PROPERTY places_found

impl Sioul

pub fn set_places_found(self: Pin<&mut Self>, value: QString)

Setter for the Q_PROPERTY places_found

impl Sioul

pub fn connect_porch_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal porchChanged , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_porch_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal porchChanged , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_budgets_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal budgetsChanged , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_budgets_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal budgetsChanged , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_accounts_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal accountsChanged , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_accounts_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal accountsChanged , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_blocked_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal blockedChanged , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_blocked_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal blockedChanged , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_status_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal statusChanged , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_status_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal statusChanged , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_busy_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal busyChanged , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_busy_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal busyChanged , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_found_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal foundChanged , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_found_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal foundChanged , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_scouted_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal scoutedChanged , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_scouted_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal scoutedChanged , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_scouting_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal scoutingChanged , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_scouting_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal scoutingChanged , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_form_error_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal formErrorChanged , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_form_error_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal formErrorChanged , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_form_busy_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal formBusyChanged , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_form_busy_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal formBusyChanged , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_mail_accounts_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal mailAccountsChanged , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_mail_accounts_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal mailAccountsChanged , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_mail_folder_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal mailFolderChanged , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_mail_folder_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal mailFolderChanged , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_drafts_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal draftsChanged , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_drafts_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal draftsChanged , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_mail_search_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal mailSearchChanged , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_mail_search_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal mailSearchChanged , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_undo_line_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal undoLineChanged , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_undo_line_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal undoLineChanged , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_contacts_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal contactsChanged , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_contacts_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal contactsChanged , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_duplicates_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal duplicatesChanged , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_duplicates_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal duplicatesChanged , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_agenda_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal agendaChanged , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_agenda_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal agendaChanged , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_overlaps_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal overlapsChanged , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_overlaps_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal overlapsChanged , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_health_view_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal healthViewChanged , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_health_view_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal healthViewChanged , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_missed_view_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal missedViewChanged , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_missed_view_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal missedViewChanged , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_needs_view_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal needsViewChanged , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_needs_view_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal needsViewChanged , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_tasks_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal tasksChanged , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_tasks_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal tasksChanged , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_notes_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal notesChanged , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_notes_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal notesChanged , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_focus_session_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal focusSessionChanged , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_focus_session_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal focusSessionChanged , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_reading_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal readingChanged , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_reading_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal readingChanged , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_realtime_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal realtimeChanged , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_realtime_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal realtimeChanged , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_away_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal awayChanged , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_away_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal awayChanged , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_mode_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal modeChanged , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_mode_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal modeChanged , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_forecast_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal forecastChanged , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_forecast_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal forecastChanged , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_places_found_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal placesFoundChanged , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_places_found_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal placesFoundChanged , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_copy_requested<F: FnMut(Pin<&mut Sioul>, QString) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal copyRequested , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_copy_requested<F: FnMut(Pin<&mut Sioul>, QString) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal copyRequested , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_account_added<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal accountAdded , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_account_added<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal accountAdded , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_account_password_done<F: FnMut(Pin<&mut Sioul>, QString, QString) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal accountPasswordDone , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_account_password_done<F: FnMut(Pin<&mut Sioul>, QString, QString) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal accountPasswordDone , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_letters_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal lettersChanged , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_letters_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal lettersChanged , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_task_done<F: FnMut(Pin<&mut Sioul>, QString) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal taskDone , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_task_done<F: FnMut(Pin<&mut Sioul>, QString) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal taskDone , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_shared_in<F: FnMut(Pin<&mut Sioul>, QString) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal sharedIn , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_shared_in<F: FnMut(Pin<&mut Sioul>, QString) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal sharedIn , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_share_listed<F: FnMut(Pin<&mut Sioul>, QString) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal shareListed , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_share_listed<F: FnMut(Pin<&mut Sioul>, QString) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal shareListed , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_share_put_back_done<F: FnMut(Pin<&mut Sioul>, QString) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal sharePutBackDone , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_share_put_back_done<F: FnMut(Pin<&mut Sioul>, QString) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal sharePutBackDone , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_share_estimated<F: FnMut(Pin<&mut Sioul>, QString) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal shareEstimated , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_share_estimated<F: FnMut(Pin<&mut Sioul>, QString) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal shareEstimated , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_spam_changed<F: FnMut(Pin<&mut Sioul>, QString) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal spamChanged , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_spam_changed<F: FnMut(Pin<&mut Sioul>, QString) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal spamChanged , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_mail_filters_found<F: FnMut(Pin<&mut Sioul>, QString) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal mailFiltersFound , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_mail_filters_found<F: FnMut(Pin<&mut Sioul>, QString) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal mailFiltersFound , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_message_read<F: FnMut(Pin<&mut Sioul>, QString, QString, QString) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal messageRead , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_message_read<F: FnMut(Pin<&mut Sioul>, QString, QString, QString) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal messageRead , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_share_started<F: FnMut(Pin<&mut Sioul>, QString) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal shareStarted , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_share_started<F: FnMut(Pin<&mut Sioul>, QString) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal shareStarted , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_reminder_opened<F: FnMut(Pin<&mut Sioul>, QString, QString, QString) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal reminderOpened , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_reminder_opened<F: FnMut(Pin<&mut Sioul>, QString, QString, QString) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal reminderOpened , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_open_url<F: FnMut(Pin<&mut Sioul>, QString) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal openUrl , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_open_url<F: FnMut(Pin<&mut Sioul>, QString) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal openUrl , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_scan_unavailable<F: FnMut(Pin<&mut Sioul>, QString, i32, i32, QString, QString, bool) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal scanUnavailable , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_scan_unavailable<F: FnMut(Pin<&mut Sioul>, QString, i32, i32, QString, QString, bool) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal scanUnavailable , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_paper_kept<F: FnMut(Pin<&mut Sioul>, QString, QString, QString) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal paperKept , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_paper_kept<F: FnMut(Pin<&mut Sioul>, QString, QString, QString) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal paperKept , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_compose_requested<F: FnMut(Pin<&mut Sioul>, QString) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal composeRequested , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_compose_requested<F: FnMut(Pin<&mut Sioul>, QString) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal composeRequested , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_draft_files_arrived<F: FnMut(Pin<&mut Sioul>, QString, QString, bool) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal draftFilesArrived , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_draft_files_arrived<F: FnMut(Pin<&mut Sioul>, QString, QString, bool) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal draftFilesArrived , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_keys_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal keysChanged , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_keys_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal keysChanged , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_security_key_changed<F: FnMut(Pin<&mut Sioul>, QString, QString) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal securityKeyChanged , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_security_key_changed<F: FnMut(Pin<&mut Sioul>, QString, QString) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal securityKeyChanged , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_links_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal linksChanged , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_links_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal linksChanged , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_places_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal placesChanged , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_places_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal placesChanged , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_sites_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal sitesChanged , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_sites_changed<F: FnMut(Pin<&mut Sioul>) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal sitesChanged , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_bitwarden_found<F: FnMut(Pin<&mut Sioul>, i32, QString) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal bitwardenFound , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_bitwarden_found<F: FnMut(Pin<&mut Sioul>, i32, QString) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal bitwardenFound , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_bitwarden_answered<F: FnMut(Pin<&mut Sioul>, i32, QString) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal bitwardenAnswered , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_bitwarden_answered<F: FnMut(Pin<&mut Sioul>, i32, QString) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal bitwardenAnswered , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub fn connect_phone_account_chosen<F: FnMut(Pin<&mut Sioul>, QString, QString) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, conn_type: ConnectionType, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal phoneAccountChosen , so that when the signal is emitted the function pointer is executed.

impl Sioul

pub fn on_phone_account_chosen<F: FnMut(Pin<&mut Sioul>, QString, QString) + 'static + Send>( self: Pin<&mut Sioul>, closure: F, ) -> QMetaObjectConnectionGuard

Connect the given function pointer to the signal phoneAccountChosen , so that when the signal is emitted the function pointer is executed.

Note that this method uses a AutoConnection connection type.

impl Sioul

pub(crate) fn shared(&self) -> Arc<Shared>

fn text(&self, id: &QString) -> QString

fn text_args(&self, id: &QString, args: &QString) -> QString

fn text_with(&self, id: &QString, name: &QString, value: &QString) -> QString

fn text_counted(&self, id: &QString, n: i32) -> QString

fn start(self: Pin<&mut Self>)

fn refresh(self: Pin<&mut Self>)

fn sync_now(self: Pin<&mut Self>)

Everything again: what is on this computer (notes, tasks, the plan, the weather) read at once; mail, agenda, tasks, contacts and GitHub fetched.

fn open_anyway(self: Pin<&mut Self>)

fn done(self: Pin<&mut Self>)

fn read_message(self: Pin<&mut Self>, key: &QString)

fn open_attachment(self: Pin<&mut Self>, key: &QString, index: i32)

fn save_attachment(self: Pin<&mut Self>, key: &QString, index: i32)

fn attachments_unscanned(&self) -> bool

fn attachment_unchecked( self: Pin<&mut Self>, key: &QString, index: i32, what: i32, )

fn keep_attachment_as_paper(self: Pin<&mut Self>, key: &QString, index: i32)

fn papers(&self) -> QString

fn save_paper(self: Pin<&mut Self>, id: &QString, edit: &QString) -> QString

fn remove_paper(self: Pin<&mut Self>, id: &QString) -> QString

fn plan_renewal(self: Pin<&mut Self>, id: &QString) -> QString

fn let_in(self: Pin<&mut Self>, address: &QString)

fn block(self: Pin<&mut Self>, entry: &QString)

fn block_from(self: Pin<&mut Self>, entry: &QString, key: &QString)

fn unblock(self: Pin<&mut Self>, entry: &QString)

fn set_standing(self: Pin<&mut Self>, entry: &QString, standing: &QString)

fn standing(&self, address: &QString) -> QString

fn standing_of(&self, addresses: &QString) -> QString

fn set_standing_of( self: Pin<&mut Self>, addresses: &QString, standing: &QString, )

fn person_of(&self, key: &QString) -> QString

fn set_person(self: Pin<&mut Self>, key: &QString, standing: &QString)

fn add_mail_line(self: Pin<&mut Self>, key: &QString, budget: &QString)

fn ignore_mail_line(self: Pin<&mut Self>, key: &QString)

fn discover(self: Pin<&mut Self>, address: &QString)

fn add_account( self: Pin<&mut Self>, address: &QString, host: &QString, port: i32, security: &QString, login: &QString, password: &QString, )

fn add_mail_like( self: Pin<&mut Self>, address: &QString, host: &QString, port: i32, security: &QString, login: &QString, )

fn set_account_enabled(self: Pin<&mut Self>, id: &QString, on: bool) -> QString

fn scout_account(self: Pin<&mut Self>, address: &QString)

fn add_portal(self: Pin<&mut Self>, name: &QString, url: &QString)

fn set_account_password(self: Pin<&mut Self>, id: &QString, password: &QString)

fn remove_account(self: Pin<&mut Self>, id: &QString)

fn set_priority(self: Pin<&mut Self>, id: &QString, priority: &QString)

fn open_folder( self: Pin<&mut Self>, account: &QString, folder: &QString, all: bool, query: &QString, )

fn opened(self: Pin<&mut Self>, key: &QString)

fn act(self: Pin<&mut Self>, key: &QString, action: &QString, target: &QString)

fn act_many(self: Pin<&mut Self>, keys: &QString, action: &QString)

fn move_messages( self: Pin<&mut Self>, keys: &QString, account: &QString, folder: &QString, )

fn unsubscribe(self: Pin<&mut Self>, key: &QString) -> QString

fn undo(self: Pin<&mut Self>)

fn flush(self: Pin<&mut Self>)

fn compose( self: Pin<&mut Self>, kind: &QString, key: &QString, account: &QString, ) -> QString

fn draft(&self, id: &QString) -> QString

fn save_draft(self: Pin<&mut Self>, edit: &QString) -> QString

fn attach(self: Pin<&mut Self>, id: &QString, url: &QString) -> QString

fn detach(self: Pin<&mut Self>, id: &QString, index: i32, forwarded: bool)

fn preview(&self, markdown: &QString) -> QString

fn send(self: Pin<&mut Self>, id: &QString) -> QString

fn discard(self: Pin<&mut Self>, id: &QString)

fn draft_closed(self: Pin<&mut Self>, id: &QString)

fn place(&self, key: &QString) -> QString

fn source(&self, key: &QString) -> QString

fn set_writing( self: Pin<&mut Self>, id: &QString, name: &QString, signature: &QString, )

fn grab_folder(&self) -> QString

fn search_contacts(self: Pin<&mut Self>, query: &QString)

fn contact(&self, key: &QString) -> QString

fn save_contact(self: Pin<&mut Self>, key: &QString, edit: &QString) -> QString

fn delete_contact(self: Pin<&mut Self>, key: &QString)

fn show_contacts_category(self: Pin<&mut Self>, category: &QString)

fn find_duplicates(self: Pin<&mut Self>)

fn clean_contacts(self: Pin<&mut Self>, keys: &QString) -> QString

fn merge_contacts( self: Pin<&mut Self>, lead: &QString, other: &QString, ) -> QString

fn not_same_contacts( self: Pin<&mut Self>, first: &QString, second: &QString, ) -> QString

fn undo_contacts(self: Pin<&mut Self>, id: &QString) -> QString

fn show_days(self: Pin<&mut Self>, from: &QString, days: i32, upcoming: bool)

fn calendars(&self) -> QString

fn event_form(&self, key: &QString) -> QString

fn save_event( self: Pin<&mut Self>, key: &QString, edit: &QString, calendar: &QString, ) -> QString

fn event_reminder(&self, key: &QString, start: f64) -> QString

fn reminder_choices(&self, current: &QString) -> QString

fn set_event_reminder( self: Pin<&mut Self>, key: &QString, value: &QString, ) -> QString

fn move_event( self: Pin<&mut Self>, key: &QString, start: f64, new_start: f64, new_end: f64, only_this: bool, ) -> QString

fn delete_event( self: Pin<&mut Self>, key: &QString, start: f64, only_this: bool, )

fn completions(&self, typed: &QString) -> QString

fn contact_for(&self, address: &QString) -> QString

fn add_sender(self: Pin<&mut Self>, name: &QString, address: &QString)

fn answer_invitation(self: Pin<&mut Self>, key: &QString, answer: &QString)

fn history_weeks(&self) -> i32

fn day_start(&self) -> i32

fn set_history(self: Pin<&mut Self>, weeks: i32)

fn add_dav( self: Pin<&mut Self>, address: &QString, url: &QString, login: &QString, password: &QString, )

fn add_google( self: Pin<&mut Self>, address: &QString, client_id: &QString, client_secret: &QString, again: &QString, )

fn cancel_google(self: Pin<&mut Self>)

fn add_google_mail( self: Pin<&mut Self>, address: &QString, client_id: &QString, client_secret: &QString, again: &QString, )

fn pgp_keys(&self) -> QString

fn pgp_generate(self: Pin<&mut Self>, address: &QString)

fn pgp_import( self: Pin<&mut Self>, url: &QString, passphrase: &QString, ) -> QString

fn pgp_export(self: Pin<&mut Self>, fingerprint: &QString)

fn pgp_save_revocation(self: Pin<&mut Self>, fingerprint: &QString)

fn pgp_remove(self: Pin<&mut Self>, fingerprint: &QString)

fn pgp_lookup(self: Pin<&mut Self>, draft: &QString)

fn security_key_for_draft(&self, id: &QString) -> QString

fn sign_and_send(self: Pin<&mut Self>, id: &QString, pin: &QString)

fn open_with_security_key(self: Pin<&mut Self>, key: &QString, pin: &QString)

fn security_key_not_now(self: Pin<&mut Self>, context: &QString)

fn let_gnupg_release(self: Pin<&mut Self>) -> QString

fn security_keys(&self) -> QString

fn read_security_key(self: Pin<&mut Self>)

fn find_security_key_certificate(self: Pin<&mut Self>, ident: &QString)

fn import_security_key_certificate( self: Pin<&mut Self>, ident: &QString, url: &QString, )

fn import_security_key_from_gnupg(self: Pin<&mut Self>, ident: &QString)

fn renew_security_key(self: Pin<&mut Self>, ident: &QString)

fn send_security_key_to_keys_openpgp(self: Pin<&mut Self>, ident: &QString)

fn forget_security_key_pin(self: Pin<&mut Self>)

fn stop_using_security_key(self: Pin<&mut Self>, ident: &QString)

fn show_tasks( self: Pin<&mut Self>, by: &QString, done: bool, query: &QString, project_id: &QString, )

fn filter_tasks(self: Pin<&mut Self>, kind: &QString, category: &QString)

fn refresh_work(self: Pin<&mut Self>)

fn show_tasks_anyway(self: Pin<&mut Self>, on: bool)

fn task(&self, uid: &QString) -> QString

fn new_task_form( &self, from: &QString, key: &QString, start: f64, list: &QString, ) -> QString

fn save_task( self: Pin<&mut Self>, uid: &QString, edit: &QString, list: &QString, ) -> QString

fn capture(&self, line: &QString) -> QString

fn add_task( self: Pin<&mut Self>, line: &QString, parent: &QString, list: &QString, ) -> QString

fn set_task_status( self: Pin<&mut Self>, uid: &QString, status: &QString, ) -> QString

fn set_felt(self: Pin<&mut Self>, uid: &QString, felt: &QString) -> QString

fn set_waits( self: Pin<&mut Self>, uid: &QString, other: &QString, wait: bool, gap_minutes: i32, ) -> QString

fn not_now(self: Pin<&mut Self>, uid: &QString)

fn set_weather(self: Pin<&mut Self>, weather: &QString)

fn set_task_at(self: Pin<&mut Self>, uid: &QString, at: &QString) -> QString

fn pin_task( self: Pin<&mut Self>, uid: &QString, at: &QString, minutes: i32, ) -> QString

fn delete_task(self: Pin<&mut Self>, uid: &QString)

fn search_tasks(&self, query: &QString, except: &QString) -> QString

fn new_list(self: Pin<&mut Self>, account: &QString, name: &QString) -> QString

fn list_accounts(&self) -> QString

fn focus_start(self: Pin<&mut Self>, uid: &QString, minutes: i32)

fn focus_pause(self: Pin<&mut Self>)

fn focus_extend(self: Pin<&mut Self>, minutes: i32)

fn focus_stop(self: Pin<&mut Self>, done: bool, note: &QString) -> QString

fn search_notes(self: Pin<&mut Self>, query: &QString)

fn note(&self, path: &QString) -> QString

fn save_note( self: Pin<&mut Self>, path: &QString, text: &QString, stamp: &QString, ) -> QString

fn create_note( self: Pin<&mut Self>, title: &QString, links: &QString, ) -> QString

fn related(&self, uri: &QString) -> QString

fn link_things(self: Pin<&mut Self>, from: &QString, to: &QString) -> QString

fn unlink_things(self: Pin<&mut Self>, from: &QString, to: &QString) -> QString

fn search_things( &self, query: &QString, kind: &QString, from: &QString, ) -> QString

fn uri_of(&self, kind: &QString, id: &QString) -> QString

fn is_program(&self, name: &QString) -> bool

fn first_frame(&self)

fn mark(&self, what: &QString)

fn phone_accounts(&self) -> bool

fn choose_phone_account(self: Pin<&mut Self>)

fn budget_detail( &self, id: &QString, anchor: &QString, step: &QString, ) -> QString

fn keep_folder( self: Pin<&mut Self>, account: &QString, folder: &QString, kept: bool, ) -> QString

fn create_folder(self: Pin<&mut Self>, account: &QString, name: &QString)

fn delete_folder(self: Pin<&mut Self>, account: &QString, folder: &QString)

fn trash_note(self: Pin<&mut Self>, path: &QString) -> QString

fn rename_note(self: Pin<&mut Self>, path: &QString, name: &QString) -> QString

fn create_note_in( self: Pin<&mut Self>, folder: &QString, title: &QString, ) -> QString

fn make_folder( self: Pin<&mut Self>, parent: &QString, name: &QString, ) -> QString

fn rename_folder( self: Pin<&mut Self>, path: &QString, name: &QString, ) -> QString

fn remove_folder(self: Pin<&mut Self>, path: &QString) -> QString

fn remove_project(self: Pin<&mut Self>, id: &QString) -> QString

fn save_budget(self: Pin<&mut Self>, id: &QString, edit: &QString) -> QString

fn letters(&self) -> QString

fn letter_task(self: Pin<&mut Self>, id: &QString) -> QString

fn letter_event(self: Pin<&mut Self>, id: &QString) -> QString

fn letter_done(self: Pin<&mut Self>, id: &QString, project: &QString) -> QString

fn bank(&self) -> QString

fn import_bank(self: Pin<&mut Self>, file: &QString) -> QString

fn import_bank_into( self: Pin<&mut Self>, file: &QString, account: &QString, ) -> QString

fn save_bank_account( self: Pin<&mut Self>, id: &QString, edit: &QString, ) -> QString

fn remove_bank_account(self: Pin<&mut Self>, id: &QString) -> QString

fn place_movement( self: Pin<&mut Self>, account: &QString, movement: &QString, choice: &QString, ) -> QString

fn save_bank_rule( self: Pin<&mut Self>, rule: &QString, edit: &QString, ) -> QString

fn remove_bank_rule(self: Pin<&mut Self>, rule: &QString) -> QString

fn save_reserve(self: Pin<&mut Self>, id: &QString, edit: &QString) -> QString

fn contracts(&self) -> QString

fn save_contract(self: Pin<&mut Self>, id: &QString, edit: &QString) -> QString

fn remove_contract(self: Pin<&mut Self>, id: &QString) -> QString

fn contract_letter(self: Pin<&mut Self>, id: &QString) -> QString

fn contract_from(&self, subject: &QString, from: &QString) -> QString

fn routines(&self) -> QString

fn save_routine( self: Pin<&mut Self>, id: &QString, title: &QString, steps: &QString, by_itself: bool, ) -> QString

fn remove_routine(self: Pin<&mut Self>, id: &QString) -> QString

fn share_status(&self, folder: &QString) -> QString

fn start_sharing( self: Pin<&mut Self>, folder: &QString, passphrase: &QString, again: &QString, ) -> QString

fn stop_sharing(self: Pin<&mut Self>) -> QString

fn share_candidates(&self) -> QString

fn set_share_projects(self: Pin<&mut Self>, on: bool) -> QString

fn folders_in(&self, path: &QString) -> QString

fn files_access(&self) -> bool

fn ask_files_access(self: Pin<&mut Self>)

fn share_now(self: Pin<&mut Self>)

fn export_time_csv( self: Pin<&mut Self>, project: &QString, from: &QString, to: &QString, target: &QString, ) -> QString

fn change_line( self: Pin<&mut Self>, uri: &QString, shown: &QString, label: &QString, amount: f64, date: &QString, ) -> QString

fn remove_budget(self: Pin<&mut Self>, what: &QString) -> QString

fn remove_line(self: Pin<&mut Self>, uri: &QString, shown: &QString) -> QString

fn noise_url(&self, kind: &QString) -> QString

fn calm_sounds(&self) -> QString

fn move_task( self: Pin<&mut Self>, uid: &QString, list: &QString, confirmed: bool, ) -> QString

fn move_contact( self: Pin<&mut Self>, key: &QString, book: &QString, confirmed: bool, ) -> QString

fn address_books(&self) -> QString

fn find_places(self: Pin<&mut Self>, name: &QString)

fn set_weather_place( self: Pin<&mut Self>, name: &QString, latitude: f64, longitude: f64, )

fn health_page(&self) -> QString

fn save_medicine(self: Pin<&mut Self>, id: &QString, edit: &QString) -> QString

fn save_prescription( self: Pin<&mut Self>, id: &QString, edit: &QString, ) -> QString

fn health_for_professional(&self, prescription: &QString) -> QString

fn remove_health(self: Pin<&mut Self>, id: &QString) -> QString

fn refilled(self: Pin<&mut Self>, id: &QString) -> QString

fn set_dose_taken(self: Pin<&mut Self>, key: &QString, taken: bool)

fn dose_not_taken(self: Pin<&mut Self>, key: &QString)

fn dose_taken_at(self: Pin<&mut Self>, key: &QString, time: &QString) -> QString

fn dose_info(&self, key: &QString) -> QString

fn dose_choose(self: Pin<&mut Self>, key: &QString, taken: bool) -> QString

fn device_off(self: Pin<&mut Self>, id: &QString, off: bool) -> QString

fn device_forget(self: Pin<&mut Self>, id: &QString) -> QString

fn needs(&self) -> QString

fn save_needs(self: Pin<&mut Self>, edit: &QString, shown: &QString) -> QString

fn skip_need(self: Pin<&mut Self>, key: &QString, skip: bool) -> QString

fn needs_today(&self) -> QString

fn refresh_health(self: Pin<&mut Self>)

fn show_health_week(self: Pin<&mut Self>, day: &QString)

fn drag_need(self: Pin<&mut Self>, edit: &QString) -> QString

fn change_need(self: Pin<&mut Self>, edit: &QString) -> QString

fn health_settings(&self) -> QString

fn wake_settings(&self, which: &QString)

fn try_wake(&self) -> QString

fn set_overlap_aside(self: Pin<&mut Self>, key: &QString) -> QString

fn move_need( self: Pin<&mut Self>, key: &QString, minutes: i32, time: &QString, ) -> QString

fn needs_later(&self) -> i32

fn missed_doses(&self) -> QString

fn going_away(self: Pin<&mut Self>)

fn back_here(self: Pin<&mut Self>)

fn touch(self: Pin<&mut Self>)

fn set_health(self: Pin<&mut Self>, key: &QString, value: &QString) -> QString

fn movement_minutes(&self) -> i32

fn chat_minute(self: Pin<&mut Self>) -> bool

fn chats_covered(&self) -> bool

fn memo_url(&self) -> QString

fn memo_recorded(self: Pin<&mut Self>, url: &QString) -> QString

fn set_notes_tree(self: Pin<&mut Self>, tree: bool)

fn view_flag(&self, name: &QString) -> bool

fn set_view_flag(self: Pin<&mut Self>, name: &QString, value: bool)

fn add_movement(self: Pin<&mut Self>, edit: &QString) -> QString

fn site_list(&self) -> QString

fn site_notified( self: Pin<&mut Self>, id: &QString, title: &QString, text: &QString, )

fn site_seen(self: Pin<&mut Self>, id: &QString)

fn site_notices(&self) -> QString

fn site_for_sender(&self, sender: &QString) -> QString

fn set_site( self: Pin<&mut Self>, id: &QString, field: &QString, value: &QString, ) -> QString

fn site_presets(&self, country: &QString, region: &QString) -> QString

fn add_site(self: Pin<&mut Self>, edit: &QString) -> QString

fn site_presets_tree(&self) -> QString

fn add_sites(self: Pin<&mut Self>, rows: &QString) -> QString

fn move_site(self: Pin<&mut Self>, id: &QString, delta: i32) -> QString

fn remove_site(self: Pin<&mut Self>, id: &QString) -> QString

fn google_built_in(&self) -> bool

fn call_devices(&self) -> QString

fn calls_script(&self) -> QString

fn set_call_device( self: Pin<&mut Self>, which: &QString, name: &QString, ) -> QString

fn bitwarden_state(&self) -> QString

fn bitwarden_unlock( self: Pin<&mut Self>, password: &QString, provider: i32, code: &QString, ) -> i32

fn bitwarden_lock(self: Pin<&mut Self>)

fn bitwarden_send_code(self: Pin<&mut Self>, password: &QString) -> i32

fn bitwarden_passkey_begin(self: Pin<&mut Self>) -> i32

fn bitwarden_passkey(self: Pin<&mut Self>, answer: &QString) -> i32

fn bitwarden_search( self: Pin<&mut Self>, url: &QString, site: &QString, user: &QString, ) -> QString

fn bitwarden_site(&self, url: &QString) -> QString

fn bitwarden_login(&self, url: &QString, id: &QString) -> QString

fn map_view(&self) -> QString

fn place_of(&self, address: &QString) -> QString

fn locate_addresses(self: Pin<&mut Self>, allow: bool)

fn refresh_mode(self: Pin<&mut Self>)

fn work_a_while(self: Pin<&mut Self>, minutes: i32)

pub(crate) fn done_for_the_day(self: Pin<&mut Self>) -> QString

fn day_review(&self, kind: &QString) -> QString

fn close_review( self: Pin<&mut Self>, kind: &QString, felt: &QString, mix: &QString, memo: &QString, ) -> QString

fn day_review_line(&self, date: &QString) -> QString

fn set_first_step(self: Pin<&mut Self>, text: &QString)

fn clear_first_step(self: Pin<&mut Self>)

fn usual_hours(self: Pin<&mut Self>)

fn set_work_now(self: Pin<&mut Self>, on: bool)

fn set_free_time(self: Pin<&mut Self>, on: bool) -> QString

fn keep_usual_end(self: Pin<&mut Self>)

fn set_free_nothing(self: Pin<&mut Self>, on: bool)

fn pause_now(self: Pin<&mut Self>)

fn come_back(self: Pin<&mut Self>) -> QString

fn lighten_tomorrow(self: Pin<&mut Self>)

fn forget_pause(self: Pin<&mut Self>)

fn pause_screen(&self) -> QString

fn pause_setup(&self) -> QString

fn open_dnd(&self, key: &QString)

fn dnd_toggle(self: Pin<&mut Self>, on: bool, minutes: i32)

fn dnd_setup(&self) -> QString

fn dnd_change(self: Pin<&mut Self>, verb: &QString, json: &QString) -> QString

fn app_notes_setup(&self) -> QString

fn app_notes_change(&self, verb: &QString, json: &QString) -> QString

fn calls_through(self: Pin<&mut Self>, on: bool, minutes: i32)

fn calls_view(&self) -> QString

fn calls_action(self: Pin<&mut Self>, verb: &QString, json: &QString) -> QString

fn calls_setup(&self) -> QString

fn phone_messages( self: Pin<&mut Self>, verb: &QString, json: &QString, ) -> QString

fn texts(self: Pin<&mut Self>, verb: &QString, json: &QString) -> QString

fn reaches_view(&self) -> QString

fn reaches_set( self: Pin<&mut Self>, row: &QString, words: &QString, shown: &QString, ) -> QString

fn reaches_preset(self: Pin<&mut Self>, id: &QString) -> QString

fn person_sheet(&self, key: &QString, addresses: &QString) -> QString

fn person_sheet_change( self: Pin<&mut Self>, key: &QString, addresses: &QString, verb: &QString, value: &QString, ) -> QString

fn attention_changed(self: Pin<&mut Self>)

The matrix changed (Settings ▸ What reaches you): the phone’s calls’ table and its modes made again, the status line, the pages shown again, your other devices told.

fn calls_setup_change( self: Pin<&mut Self>, verb: &QString, json: &QString, ) -> QString

fn change_overrides(self: Pin<&mut Self>, change: impl FnOnce(&mut Overrides))

The overrides changed, then every page shown again for the time it is.

fn project_rows(&self) -> QString

fn project_page(&self, id: &QString) -> QString

fn save_project(self: Pin<&mut Self>, id: &QString, edit: &QString) -> QString

fn time_page( &self, period: &QString, anchor: &QString, project: &QString, ) -> QString

fn note_time(self: Pin<&mut Self>, edit: &QString) -> QString

fn stopped(&self) -> QString

fn set_stopped(self: Pin<&mut Self>, text: &QString) -> QString

fn change_time(self: Pin<&mut Self>, key: &QString, edit: &QString) -> QString

fn task_choices(&self, keep: &QString) -> QString

fn remove_time(self: Pin<&mut Self>, key: &QString) -> QString

fn take_invoices(self: Pin<&mut Self>) -> QString

fn make_invoice(self: Pin<&mut Self>, id: &QString) -> QString

fn invoice_again(&self, number: &QString) -> QString

fn set_invoice_paid( self: Pin<&mut Self>, number: &QString, paid: bool, ) -> QString

fn make_linked( self: Pin<&mut Self>, kind: &QString, from: &QString, key: &QString, start: f64, ) -> QString

fn task_from_mail(self: Pin<&mut Self>, key: &QString) -> QString

fn note_from_mail(self: Pin<&mut Self>, key: &QString) -> QString

fn note_from_event(self: Pin<&mut Self>, key: &QString, start: f64) -> QString

fn task_from_event(self: Pin<&mut Self>, key: &QString, start: f64) -> QString

fn task_from_line(self: Pin<&mut Self>, path: &QString, line: i32) -> QString

fn draft_for_task(self: Pin<&mut Self>, uid: &QString) -> QString

fn mail_note(self: Pin<&mut Self>, path: &QString) -> QString

fn settings(&self, view: &QString) -> QString

fn set_setting(self: Pin<&mut Self>, key: &QString, value: &QString) -> QString

fn change_setting( self: Pin<&mut Self>, key: &QString, shown: &QString, value: &QString, ) -> QString

fn forced_theme(&self) -> QString

fn set_realtime_mode(self: Pin<&mut Self>, on: bool)

fn grab_phone(&self) -> bool

fn grab_steps(&self) -> QString

impl Sioul

fn set_notes_carried(self: Pin<&mut Self>, carried: bool) -> QString

fn set_share_part(self: Pin<&mut Self>, part: &QString, on: bool) -> QString

fn share_history(self: Pin<&mut Self>, filter: &QString)

fn share_put_back_preview( &self, part: &QString, file: &QString, stamp: &QString, ) -> QString

fn share_put_back( self: Pin<&mut Self>, part: &QString, file: &QString, stamp: &QString, )

fn share_confirm_gone(self: Pin<&mut Self>, store: &QString) -> QString

fn share_estimate(self: Pin<&mut Self>, part: &QString)

fn spam_status(&self) -> QString

fn spam_train(self: Pin<&mut Self>) -> QString

fn spam_stop(self: Pin<&mut Self>)

fn mail_filters(&self) -> QString

fn set_mail_filters( self: Pin<&mut Self>, filters: &QString, shown: &QString, ) -> QString

fn mail_filter_said(&self, filter: &QString) -> QString

fn mail_filter_try(self: Pin<&mut Self>, filter: &QString)

fn mail_filters_preview(self: Pin<&mut Self>)

fn mail_filters_run(self: Pin<&mut Self>) -> QString

fn new_mail_filter(self: Pin<&mut Self>, given: &QString) -> QString

fn set_share_backup(self: Pin<&mut Self>, on: bool) -> QString

fn set_share_send(self: Pin<&mut Self>, on: bool) -> QString

fn share_send_again(self: Pin<&mut Self>)

fn share_backup_place(self: Pin<&mut Self>, place: &QString) -> QString

fn start_sharing_on_server( self: Pin<&mut Self>, account: &QString, place: &QString, passphrase: &QString, again: &QString, )

impl Sioul

pub(crate) fn search_mail(self: Pin<&mut Self>, conditions: &QString, now: bool)

pub(crate) fn clear_mail_search(self: Pin<&mut Self>)

pub(crate) fn bring_message(self: Pin<&mut Self>, key: &QString)

pub(crate) fn mail_search_fields(&self) -> QString

Trait Implementations

impl CxxQtType for Sioul

type Rust = SioulRust

The Rust type that this QObject is wrapping.

fn rust(&self) -> &Self::Rust

Retrieve an immutable reference to the Rust struct backing this C++ object

fn rust_mut(self: Pin<&mut Self>) -> Pin<&mut Self::Rust>

Retrieve a mutable reference to the Rust struct backing this C++ object

impl Deref for Sioul

type Target = SioulRust

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl ExternType for Sioul

type Kind = Opaque

Either cxx::kind::Opaque or cxx::kind::Trivial.

type Id

A type-level representation of the type’s C++ namespace and type name.

impl Threading for Sioul

fn qt_thread(&self) -> CxxQtThread<Sioul>

Create an instance of a [CxxQtThread]

impl Upcast<QObject> for Sioul

fn upcast(&self) -> &T

Upcast a reference to self to a reference to the base class

fn upcast_mut(&mut self) -> &mut T

Upcast a mutable reference to sell to a mutable reference to the base class

fn upcast_pin(self: Pin<&mut Self>) -> Pin<&mut T>

Upcast a pinned mutable reference to self to a pinned mutable reference to the base class