1use glib::translate::*;
7
8use crate::{
9 ffi, prelude::*, subclass::prelude::*, TextBuffer, TextChildAnchor, TextIter, TextMark, TextTag,
10};
11
12pub trait TextBufferImpl: ObjectImpl + ObjectSubclass<Type: IsA<TextBuffer>> {
13 fn apply_tag(&self, tag: &TextTag, start: &TextIter, end: &TextIter) {
14 self.parent_apply_tag(tag, start, end)
15 }
16 fn begin_user_action(&self) {
17 self.parent_begin_user_action()
18 }
19 fn changed(&self) {
20 self.parent_changed()
21 }
22 fn delete_range(&self, start: &mut TextIter, end: &mut TextIter) {
23 self.parent_delete_range(start, end)
24 }
25 fn end_user_action(&self) {
26 self.parent_end_user_action()
27 }
28 fn insert_child_anchor(&self, iter: &mut TextIter, anchor: &TextChildAnchor) {
29 self.parent_insert_child_anchor(iter, anchor)
30 }
31 fn insert_paintable(&self, iter: &mut TextIter, paintable: &gdk::Paintable) {
32 self.parent_insert_paintable(iter, paintable)
33 }
34 fn insert_text(&self, iter: &mut TextIter, new_text: &str) {
35 self.parent_insert_text(iter, new_text)
36 }
37 fn mark_deleted(&self, mark: &TextMark) {
38 self.parent_mark_deleted(mark);
39 }
40 fn mark_set(&self, location: &TextIter, mark: &TextMark) {
41 self.parent_mark_set(location, mark)
42 }
43 fn modified_changed(&self) {
44 self.parent_modified_changed();
45 }
46 fn paste_done(&self, clipboard: &gdk::Clipboard) {
47 self.parent_paste_done(clipboard)
48 }
49 fn redo(&self) {
50 self.parent_redo()
51 }
52 fn remove_tag(&self, tag: &TextTag, start: &TextIter, end: &TextIter) {
53 self.parent_remove_tag(tag, start, end)
54 }
55 fn undo(&self) {
56 self.parent_undo()
57 }
58}
59
60pub trait TextBufferImplExt: TextBufferImpl {
61 fn parent_apply_tag(&self, tag: &TextTag, start: &TextIter, end: &TextIter) {
62 unsafe {
63 let data = Self::type_data();
64 let parent_class = data.as_ref().parent_class() as *mut ffi::GtkTextBufferClass;
65 if let Some(f) = (*parent_class).apply_tag {
66 f(
67 self.obj().unsafe_cast_ref::<TextBuffer>().to_glib_none().0,
68 tag.to_glib_none().0,
69 start.to_glib_none().0,
70 end.to_glib_none().0,
71 )
72 }
73 }
74 }
75
76 fn parent_begin_user_action(&self) {
77 unsafe {
78 let data = Self::type_data();
79 let parent_class = data.as_ref().parent_class() as *mut ffi::GtkTextBufferClass;
80 if let Some(f) = (*parent_class).begin_user_action {
81 f(self.obj().unsafe_cast_ref::<TextBuffer>().to_glib_none().0)
82 }
83 }
84 }
85
86 fn parent_changed(&self) {
87 unsafe {
88 let data = Self::type_data();
89 let parent_class = data.as_ref().parent_class() as *mut ffi::GtkTextBufferClass;
90 if let Some(f) = (*parent_class).changed {
91 f(self.obj().unsafe_cast_ref::<TextBuffer>().to_glib_none().0)
92 }
93 }
94 }
95
96 fn parent_delete_range(&self, start: &mut TextIter, end: &mut TextIter) {
97 unsafe {
98 let data = Self::type_data();
99 let parent_class = data.as_ref().parent_class() as *mut ffi::GtkTextBufferClass;
100 if let Some(f) = (*parent_class).delete_range {
101 f(
102 self.obj().unsafe_cast_ref::<TextBuffer>().to_glib_none().0,
103 start.to_glib_none_mut().0,
104 end.to_glib_none_mut().0,
105 )
106 }
107 }
108 }
109
110 fn parent_end_user_action(&self) {
111 unsafe {
112 let data = Self::type_data();
113 let parent_class = data.as_ref().parent_class() as *mut ffi::GtkTextBufferClass;
114 if let Some(f) = (*parent_class).end_user_action {
115 f(self.obj().unsafe_cast_ref::<TextBuffer>().to_glib_none().0)
116 }
117 }
118 }
119
120 fn parent_insert_child_anchor(&self, iter: &mut TextIter, anchor: &TextChildAnchor) {
121 unsafe {
122 let data = Self::type_data();
123 let parent_class = data.as_ref().parent_class() as *mut ffi::GtkTextBufferClass;
124 if let Some(f) = (*parent_class).insert_child_anchor {
125 f(
126 self.obj().unsafe_cast_ref::<TextBuffer>().to_glib_none().0,
127 iter.to_glib_none_mut().0,
128 anchor.to_glib_none().0,
129 )
130 }
131 }
132 }
133
134 fn parent_insert_paintable(&self, iter: &mut TextIter, paintable: &gdk::Paintable) {
135 unsafe {
136 let data = Self::type_data();
137 let parent_class = data.as_ref().parent_class() as *mut ffi::GtkTextBufferClass;
138 if let Some(f) = (*parent_class).insert_paintable {
139 f(
140 self.obj().unsafe_cast_ref::<TextBuffer>().to_glib_none().0,
141 iter.to_glib_none_mut().0,
142 paintable.to_glib_none().0,
143 )
144 }
145 }
146 }
147
148 fn parent_insert_text(&self, iter: &mut TextIter, new_text: &str) {
149 unsafe {
150 let data = Self::type_data();
151 let parent_class = data.as_ref().parent_class() as *mut ffi::GtkTextBufferClass;
152 if let Some(f) = (*parent_class).insert_text {
153 f(
154 self.obj().unsafe_cast_ref::<TextBuffer>().to_glib_none().0,
155 iter.to_glib_none_mut().0,
156 new_text.to_glib_none().0,
157 new_text.len() as i32,
158 )
159 }
160 }
161 }
162
163 fn parent_mark_deleted(&self, mark: &TextMark) {
164 unsafe {
165 let data = Self::type_data();
166 let parent_class = data.as_ref().parent_class() as *mut ffi::GtkTextBufferClass;
167 if let Some(f) = (*parent_class).mark_deleted {
168 f(
169 self.obj().unsafe_cast_ref::<TextBuffer>().to_glib_none().0,
170 mark.to_glib_none().0,
171 )
172 }
173 }
174 }
175
176 fn parent_mark_set(&self, location: &TextIter, mark: &TextMark) {
177 unsafe {
178 let data = Self::type_data();
179 let parent_class = data.as_ref().parent_class() as *mut ffi::GtkTextBufferClass;
180 if let Some(f) = (*parent_class).mark_set {
181 f(
182 self.obj().unsafe_cast_ref::<TextBuffer>().to_glib_none().0,
183 location.to_glib_none().0,
184 mark.to_glib_none().0,
185 )
186 }
187 }
188 }
189
190 fn parent_modified_changed(&self) {
191 unsafe {
192 let data = Self::type_data();
193 let parent_class = data.as_ref().parent_class() as *mut ffi::GtkTextBufferClass;
194 if let Some(f) = (*parent_class).modified_changed {
195 f(self.obj().unsafe_cast_ref::<TextBuffer>().to_glib_none().0)
196 }
197 }
198 }
199
200 fn parent_paste_done(&self, clipboard: &gdk::Clipboard) {
201 unsafe {
202 let data = Self::type_data();
203 let parent_class = data.as_ref().parent_class() as *mut ffi::GtkTextBufferClass;
204 if let Some(f) = (*parent_class).paste_done {
205 f(
206 self.obj().unsafe_cast_ref::<TextBuffer>().to_glib_none().0,
207 clipboard.to_glib_none().0,
208 )
209 }
210 }
211 }
212
213 fn parent_redo(&self) {
214 unsafe {
215 let data = Self::type_data();
216 let parent_class = data.as_ref().parent_class() as *mut ffi::GtkTextBufferClass;
217 if let Some(f) = (*parent_class).redo {
218 f(self.obj().unsafe_cast_ref::<TextBuffer>().to_glib_none().0)
219 }
220 }
221 }
222
223 fn parent_remove_tag(&self, tag: &TextTag, start: &TextIter, end: &TextIter) {
224 unsafe {
225 let data = Self::type_data();
226 let parent_class = data.as_ref().parent_class() as *mut ffi::GtkTextBufferClass;
227 if let Some(f) = (*parent_class).remove_tag {
228 f(
229 self.obj().unsafe_cast_ref::<TextBuffer>().to_glib_none().0,
230 tag.to_glib_none().0,
231 start.to_glib_none().0,
232 end.to_glib_none().0,
233 )
234 }
235 }
236 }
237
238 fn parent_undo(&self) {
239 unsafe {
240 let data = Self::type_data();
241 let parent_class = data.as_ref().parent_class() as *mut ffi::GtkTextBufferClass;
242 if let Some(f) = (*parent_class).undo {
243 f(self.obj().unsafe_cast_ref::<TextBuffer>().to_glib_none().0)
244 }
245 }
246 }
247}
248
249impl<T: TextBufferImpl> TextBufferImplExt for T {}
250
251unsafe impl<T: TextBufferImpl> IsSubclassable<T> for TextBuffer {
252 fn class_init(class: &mut glib::Class<Self>) {
253 Self::parent_class_init::<T>(class);
254
255 assert_initialized_main_thread!();
256
257 let klass = class.as_mut();
258 klass.apply_tag = Some(text_buffer_apply_tag::<T>);
259 klass.begin_user_action = Some(text_buffer_begin_user_action::<T>);
260 klass.changed = Some(text_buffer_changed::<T>);
261 klass.delete_range = Some(text_buffer_delete_range::<T>);
262 klass.end_user_action = Some(text_buffer_end_user_action::<T>);
263 klass.insert_child_anchor = Some(text_buffer_insert_child_anchor::<T>);
264 klass.insert_paintable = Some(text_buffer_insert_paintable::<T>);
265 klass.insert_text = Some(text_buffer_insert_text::<T>);
266 klass.mark_deleted = Some(text_buffer_mark_deleted::<T>);
267 klass.mark_set = Some(text_buffer_mark_set::<T>);
268 klass.modified_changed = Some(text_buffer_modified_changed::<T>);
269 klass.paste_done = Some(text_buffer_paste_done::<T>);
270 klass.remove_tag = Some(text_buffer_remove_tag::<T>);
271 klass.redo = Some(text_buffer_redo::<T>);
272 klass.undo = Some(text_buffer_undo::<T>);
273 }
274}
275
276unsafe extern "C" fn text_buffer_apply_tag<T: TextBufferImpl>(
277 ptr: *mut ffi::GtkTextBuffer,
278 tag_ptr: *mut ffi::GtkTextTag,
279 start_ptr: *const ffi::GtkTextIter,
280 end_ptr: *const ffi::GtkTextIter,
281) {
282 let instance = &*(ptr as *mut T::Instance);
283 let imp = instance.imp();
284
285 imp.apply_tag(
286 &from_glib_borrow(tag_ptr),
287 &from_glib_borrow(start_ptr),
288 &from_glib_borrow(end_ptr),
289 )
290}
291
292unsafe extern "C" fn text_buffer_begin_user_action<T: TextBufferImpl>(
293 ptr: *mut ffi::GtkTextBuffer,
294) {
295 let instance = &*(ptr as *mut T::Instance);
296 let imp = instance.imp();
297
298 imp.begin_user_action()
299}
300
301unsafe extern "C" fn text_buffer_changed<T: TextBufferImpl>(ptr: *mut ffi::GtkTextBuffer) {
302 let instance = &*(ptr as *mut T::Instance);
303 let imp = instance.imp();
304
305 imp.changed()
306}
307
308unsafe extern "C" fn text_buffer_delete_range<T: TextBufferImpl>(
309 ptr: *mut ffi::GtkTextBuffer,
310 start_ptr: *mut ffi::GtkTextIter,
311 end_ptr: *mut ffi::GtkTextIter,
312) {
313 let instance = &*(ptr as *mut T::Instance);
314 let imp = instance.imp();
315
316 let mut start_copy = from_glib_none(start_ptr);
317 let mut end_copy = from_glib_none(end_ptr);
318
319 imp.delete_range(&mut start_copy, &mut end_copy);
320
321 *start_ptr = *start_copy.to_glib_none().0;
322 *end_ptr = *end_copy.to_glib_none().0;
323}
324
325unsafe extern "C" fn text_buffer_end_user_action<T: TextBufferImpl>(ptr: *mut ffi::GtkTextBuffer) {
326 let instance = &*(ptr as *mut T::Instance);
327 let imp = instance.imp();
328
329 imp.end_user_action()
330}
331
332unsafe extern "C" fn text_buffer_insert_child_anchor<T: TextBufferImpl>(
333 ptr: *mut ffi::GtkTextBuffer,
334 iter_ptr: *mut ffi::GtkTextIter,
335 anchor_ptr: *mut ffi::GtkTextChildAnchor,
336) {
337 let instance = &*(ptr as *mut T::Instance);
338 let imp = instance.imp();
339
340 let mut iter = from_glib_none(iter_ptr);
341
342 imp.insert_child_anchor(&mut iter, &from_glib_borrow(anchor_ptr));
343 *iter_ptr = *iter.to_glib_none().0;
344}
345
346unsafe extern "C" fn text_buffer_insert_paintable<T: TextBufferImpl>(
347 ptr: *mut ffi::GtkTextBuffer,
348 iter_ptr: *mut ffi::GtkTextIter,
349 paintable_ptr: *mut gdk::ffi::GdkPaintable,
350) {
351 let instance = &*(ptr as *mut T::Instance);
352 let imp = instance.imp();
353
354 let mut iter = from_glib_none(iter_ptr);
355
356 imp.insert_paintable(&mut iter, &from_glib_borrow(paintable_ptr));
357 *iter_ptr = *iter.to_glib_none().0;
358}
359
360unsafe extern "C" fn text_buffer_insert_text<T: TextBufferImpl>(
361 ptr: *mut ffi::GtkTextBuffer,
362 iter_ptr: *mut ffi::GtkTextIter,
363 text_ptr: *const libc::c_char,
364 _length: libc::c_int,
365) {
366 let instance = &*(ptr as *mut T::Instance);
367 let imp = instance.imp();
368 let text: Borrowed<glib::GString> = from_glib_borrow(text_ptr);
369
370 let mut iter = from_glib_none(iter_ptr);
371
372 imp.insert_text(&mut iter, text.as_str());
373 *iter_ptr = *iter.to_glib_none().0;
374}
375
376unsafe extern "C" fn text_buffer_modified_changed<T: TextBufferImpl>(ptr: *mut ffi::GtkTextBuffer) {
377 let instance = &*(ptr as *mut T::Instance);
378 let imp = instance.imp();
379
380 imp.modified_changed()
381}
382
383unsafe extern "C" fn text_buffer_mark_deleted<T: TextBufferImpl>(
384 ptr: *mut ffi::GtkTextBuffer,
385 mark: *mut ffi::GtkTextMark,
386) {
387 let instance = &*(ptr as *mut T::Instance);
388 let imp = instance.imp();
389
390 imp.mark_deleted(&from_glib_borrow(mark))
391}
392
393unsafe extern "C" fn text_buffer_mark_set<T: TextBufferImpl>(
394 ptr: *mut ffi::GtkTextBuffer,
395 iter: *const ffi::GtkTextIter,
396 mark: *mut ffi::GtkTextMark,
397) {
398 let instance = &*(ptr as *mut T::Instance);
399 let imp = instance.imp();
400
401 imp.mark_set(&from_glib_borrow(iter), &from_glib_borrow(mark))
402}
403
404unsafe extern "C" fn text_buffer_paste_done<T: TextBufferImpl>(
405 ptr: *mut ffi::GtkTextBuffer,
406 clipboard_ptr: *mut gdk::ffi::GdkClipboard,
407) {
408 let instance = &*(ptr as *mut T::Instance);
409 let imp = instance.imp();
410
411 imp.paste_done(&from_glib_borrow(clipboard_ptr))
412}
413
414unsafe extern "C" fn text_buffer_redo<T: TextBufferImpl>(ptr: *mut ffi::GtkTextBuffer) {
415 let instance = &*(ptr as *mut T::Instance);
416 let imp = instance.imp();
417
418 imp.redo()
419}
420
421unsafe extern "C" fn text_buffer_remove_tag<T: TextBufferImpl>(
422 ptr: *mut ffi::GtkTextBuffer,
423 tag: *mut ffi::GtkTextTag,
424 start: *const ffi::GtkTextIter,
425 end: *const ffi::GtkTextIter,
426) {
427 let instance = &*(ptr as *mut T::Instance);
428 let imp = instance.imp();
429
430 imp.remove_tag(
431 &from_glib_borrow(tag),
432 &from_glib_borrow(start),
433 &from_glib_borrow(end),
434 )
435}
436
437unsafe extern "C" fn text_buffer_undo<T: TextBufferImpl>(ptr: *mut ffi::GtkTextBuffer) {
438 let instance = &*(ptr as *mut T::Instance);
439 let imp = instance.imp();
440
441 imp.undo()
442}