sourceview5/auto/
completion_provider.rs1use crate::{ffi, CompletionCell, CompletionContext, CompletionProposal};
7use glib::{prelude::*, translate::*};
8use std::{boxed::Box as Box_, pin::Pin};
9
10glib::wrapper! {
11 #[doc(alias = "GtkSourceCompletionProvider")]
12 pub struct CompletionProvider(Interface<ffi::GtkSourceCompletionProvider, ffi::GtkSourceCompletionProviderInterface>);
13
14 match fn {
15 type_ => || ffi::gtk_source_completion_provider_get_type(),
16 }
17}
18
19impl CompletionProvider {
20 pub const NONE: Option<&'static CompletionProvider> = None;
21}
22
23mod sealed {
24 pub trait Sealed {}
25 impl<T: super::IsA<super::CompletionProvider>> Sealed for T {}
26}
27
28pub trait CompletionProviderExt: IsA<CompletionProvider> + sealed::Sealed + 'static {
29 #[doc(alias = "gtk_source_completion_provider_activate")]
30 fn activate(&self, context: &CompletionContext, proposal: &impl IsA<CompletionProposal>) {
31 unsafe {
32 ffi::gtk_source_completion_provider_activate(
33 self.as_ref().to_glib_none().0,
34 context.to_glib_none().0,
35 proposal.as_ref().to_glib_none().0,
36 );
37 }
38 }
39
40 #[doc(alias = "gtk_source_completion_provider_display")]
41 fn display(
42 &self,
43 context: &CompletionContext,
44 proposal: &impl IsA<CompletionProposal>,
45 cell: &CompletionCell,
46 ) {
47 unsafe {
48 ffi::gtk_source_completion_provider_display(
49 self.as_ref().to_glib_none().0,
50 context.to_glib_none().0,
51 proposal.as_ref().to_glib_none().0,
52 cell.to_glib_none().0,
53 );
54 }
55 }
56
57 #[doc(alias = "gtk_source_completion_provider_get_priority")]
58 #[doc(alias = "get_priority")]
59 fn priority(&self, context: &CompletionContext) -> i32 {
60 unsafe {
61 ffi::gtk_source_completion_provider_get_priority(
62 self.as_ref().to_glib_none().0,
63 context.to_glib_none().0,
64 )
65 }
66 }
67
68 #[doc(alias = "gtk_source_completion_provider_get_title")]
69 #[doc(alias = "get_title")]
70 fn title(&self) -> Option<glib::GString> {
71 unsafe {
72 from_glib_full(ffi::gtk_source_completion_provider_get_title(
73 self.as_ref().to_glib_none().0,
74 ))
75 }
76 }
77
78 #[doc(alias = "gtk_source_completion_provider_is_trigger")]
79 fn is_trigger(&self, iter: >k::TextIter, ch: char) -> bool {
80 unsafe {
81 from_glib(ffi::gtk_source_completion_provider_is_trigger(
82 self.as_ref().to_glib_none().0,
83 iter.to_glib_none().0,
84 ch.into_glib(),
85 ))
86 }
87 }
88
89 #[doc(alias = "gtk_source_completion_provider_key_activates")]
90 fn key_activates(
91 &self,
92 context: &CompletionContext,
93 proposal: &impl IsA<CompletionProposal>,
94 keyval: u32,
95 state: gdk::ModifierType,
96 ) -> bool {
97 unsafe {
98 from_glib(ffi::gtk_source_completion_provider_key_activates(
99 self.as_ref().to_glib_none().0,
100 context.to_glib_none().0,
101 proposal.as_ref().to_glib_none().0,
102 keyval,
103 state.into_glib(),
104 ))
105 }
106 }
107
108 #[doc(alias = "gtk_source_completion_provider_list_alternates")]
109 fn list_alternates(
110 &self,
111 context: &CompletionContext,
112 proposal: &impl IsA<CompletionProposal>,
113 ) -> Vec<CompletionProposal> {
114 unsafe {
115 FromGlibPtrContainer::from_glib_full(
116 ffi::gtk_source_completion_provider_list_alternates(
117 self.as_ref().to_glib_none().0,
118 context.to_glib_none().0,
119 proposal.as_ref().to_glib_none().0,
120 ),
121 )
122 }
123 }
124
125 #[doc(alias = "gtk_source_completion_provider_populate_async")]
126 fn populate_async<P: FnOnce(Result<gio::ListModel, glib::Error>) + 'static>(
127 &self,
128 context: &CompletionContext,
129 cancellable: Option<&impl IsA<gio::Cancellable>>,
130 callback: P,
131 ) {
132 let main_context = glib::MainContext::ref_thread_default();
133 let is_main_context_owner = main_context.is_owner();
134 let has_acquired_main_context = (!is_main_context_owner)
135 .then(|| main_context.acquire().ok())
136 .flatten();
137 assert!(
138 is_main_context_owner || has_acquired_main_context.is_some(),
139 "Async operations only allowed if the thread is owning the MainContext"
140 );
141
142 let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
143 Box_::new(glib::thread_guard::ThreadGuard::new(callback));
144 unsafe extern "C" fn populate_async_trampoline<
145 P: FnOnce(Result<gio::ListModel, glib::Error>) + 'static,
146 >(
147 _source_object: *mut glib::gobject_ffi::GObject,
148 res: *mut gio::ffi::GAsyncResult,
149 user_data: glib::ffi::gpointer,
150 ) {
151 let mut error = std::ptr::null_mut();
152 let ret = ffi::gtk_source_completion_provider_populate_finish(
153 _source_object as *mut _,
154 res,
155 &mut error,
156 );
157 let result = if error.is_null() {
158 Ok(from_glib_full(ret))
159 } else {
160 Err(from_glib_full(error))
161 };
162 let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
163 Box_::from_raw(user_data as *mut _);
164 let callback: P = callback.into_inner();
165 callback(result);
166 }
167 let callback = populate_async_trampoline::<P>;
168 unsafe {
169 ffi::gtk_source_completion_provider_populate_async(
170 self.as_ref().to_glib_none().0,
171 context.to_glib_none().0,
172 cancellable.map(|p| p.as_ref()).to_glib_none().0,
173 Some(callback),
174 Box_::into_raw(user_data) as *mut _,
175 );
176 }
177 }
178
179 fn populate_future(
180 &self,
181 context: &CompletionContext,
182 ) -> Pin<Box_<dyn std::future::Future<Output = Result<gio::ListModel, glib::Error>> + 'static>>
183 {
184 let context = context.clone();
185 Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
186 obj.populate_async(&context, Some(cancellable), move |res| {
187 send.resolve(res);
188 });
189 }))
190 }
191
192 #[doc(alias = "gtk_source_completion_provider_refilter")]
193 fn refilter(&self, context: &CompletionContext, model: &impl IsA<gio::ListModel>) {
194 unsafe {
195 ffi::gtk_source_completion_provider_refilter(
196 self.as_ref().to_glib_none().0,
197 context.to_glib_none().0,
198 model.as_ref().to_glib_none().0,
199 );
200 }
201 }
202}
203
204impl<O: IsA<CompletionProvider>> CompletionProviderExt for O {}