1#[doc(hidden)]
2#[macro_export]
3macro_rules! impl_display_ext {
5 ($name: ident, $flname: ident) => {
6 paste::paste! {
7 unsafe impl DisplayExt for $name {
8 fn buffer(&self) -> Option<$crate::text::TextBuffer> {
9 unsafe {
10 let buffer = [<$flname _get_buffer>](self.inner.widget() as _);
11 if buffer.is_null() {
12 None
13 } else {
14 let buf = $crate::text::TextBuffer::from_ptr(buffer);
15 Some(buf)
16 }
17 }
18 }
19
20 fn has_buffer(&self) -> bool {
21 unsafe {
22 let buffer = [<$flname _get_buffer>](self.inner.widget() as _);
23 !buffer.is_null()
24 }
25 }
26
27 fn set_buffer<B: Into<Option<$crate::text::TextBuffer>>>(&mut self, buffer: B) {
28 unsafe {
29 if let Some(buffer) = buffer.into() {
30 [<$flname _set_buffer>](self.inner.widget() as _, buffer.as_ptr())
31 } else {
32 [<$flname _set_buffer>](
33 self.inner.widget() as _,
34 std::ptr::null_mut() as *mut Fl_Text_Buffer,
35 )
36 }
37 }
38 }
39
40 fn style_buffer(&self) -> Option<$crate::text::TextBuffer> {
41 unsafe {
42 let buffer = [<$flname _get_style_buffer>](self.inner.widget() as _);
43 if buffer.is_null() {
44 None
45 } else {
46 let buf = $crate::text::TextBuffer::from_ptr(buffer);
47 Some(buf)
48 }
49 }
50 }
51
52 fn text_font(&self) -> $crate::enums::Font {
53 assert!(self.has_buffer());
54 unsafe { std::mem::transmute([<$flname _text_font>](self.inner.widget() as _)) }
55 }
56
57 fn set_text_font(&mut self, font: $crate::enums::Font) {
58 unsafe { [<$flname _set_text_font>](self.inner.widget() as _, font.bits() as i32) }
59 }
60
61 fn text_color(&self) -> $crate::enums::Color {
62 assert!(self.has_buffer());
63 unsafe { std::mem::transmute([<$flname _text_color>](self.inner.widget() as _)) }
64 }
65
66 fn set_text_color(&mut self, color: $crate::enums::Color) {
67 unsafe { [<$flname _set_text_color>](self.inner.widget() as _, color.bits() as u32) }
68 }
69
70 fn text_size(&self) -> i32 {
71 assert!(self.has_buffer());
72 unsafe { [<$flname _text_size>](self.inner.widget() as _) as i32 }
73 }
74
75 fn set_text_size(&mut self, sz: i32) {
76 unsafe { [<$flname _set_text_size>](self.inner.widget() as _, sz as i32) }
77 }
78
79 fn scroll(&mut self, top_line_num: i32, h_offset: i32) {
80 unsafe {
81 assert!(self.has_buffer());
82 [<$flname _scroll>](
83 self.inner.widget() as _,
84 top_line_num as i32,
85 h_offset as i32,
86 )
87 }
88 }
89
90 fn insert(&self, text: &str) {
91 let text = CString::safe_new(text);
92 unsafe {
93 assert!(self.has_buffer());
94 [<$flname _insert>](self.inner.widget() as _, text.as_ptr())
95 }
96 }
97
98 fn set_insert_position(&mut self, new_pos: i32) {
99 unsafe {
100 assert!(self.has_buffer());
101 [<$flname _set_insert_position>](self.inner.widget() as _, new_pos as i32)
102 }
103 }
104
105 fn insert_position(&self) -> i32 {
106 unsafe {
107 assert!(self.has_buffer());
108 [<$flname _insert_position>](self.inner.widget() as _) as i32
109 }
110 }
111
112 fn position_to_xy(&self, pos: i32) -> (i32, i32) {
113 unsafe {
114 let mut x: i32 = 0;
115 let mut y: i32 = 0;
116
117 assert!(self.has_buffer());
118 [<$flname _position_to_xy>](
119 self.inner.widget() as _, pos as i32, &mut x, &mut y,
120 );
121 (x as i32, y as i32)
122 }
123 }
124
125 fn count_lines(&self, start: i32, end: i32, is_line_start: bool) -> i32 {
126 let x = match is_line_start {
127 true => 1,
128 false => 0,
129 };
130 unsafe {
131 assert!(self.has_buffer());
132 [<$flname _count_lines>](self.inner.widget() as _, start as i32, end as i32, x)
133 as i32
134 }
135 }
136
137 fn move_right(&mut self) -> Result<(), FltkError> {
138 unsafe {
139 assert!(self.has_buffer());
140 let x = [<$flname _move_right>](self.inner.widget() as _);
141 if x == 0 {
142 Err(FltkError::Internal(FltkErrorKind::FailedOperation))
143 } else {
144 Ok(())
145 }
146 }
147 }
148
149 fn move_left(&mut self) -> Result<(), FltkError> {
150 unsafe {
151 assert!(self.has_buffer());
152 let x = [<$flname _move_left>](self.inner.widget() as _);
153 if x == 0 {
154 Err(FltkError::Internal(FltkErrorKind::FailedOperation))
155 } else {
156 Ok(())
157 }
158 }
159 }
160
161 fn move_up(&mut self) -> Result<(), FltkError> {
162 unsafe {
163 assert!(self.has_buffer());
164 let x = [<$flname _move_up>](self.inner.widget() as _);
165 if x == 0 {
166 Err(FltkError::Internal(FltkErrorKind::FailedOperation))
167 } else {
168 Ok(())
169 }
170 }
171 }
172
173 fn move_down(&mut self) -> Result<(), FltkError> {
174 unsafe {
175 assert!(self.has_buffer());
176 let x = [<$flname _move_down>](self.inner.widget() as _);
177 if x == 0 {
178 Err(FltkError::Internal(FltkErrorKind::FailedOperation))
179 } else {
180 Ok(())
181 }
182 }
183 }
184
185 fn show_cursor(&mut self, val: bool) {
186 unsafe {
187 [<$flname _show_cursor>](self.inner.widget() as _, val as i32);
188 }
189 }
190
191 fn set_highlight_data<B: Into<Option<$crate::text::TextBuffer>>, E: Into<Vec<$crate::text::StyleTableEntry>>>(
192 &mut self,
193 style_buffer: B,
194 entries: E,
195 ) {
196 let entries = entries.into();
197
198 assert!(entries.len() < 127);
199 let entries = if entries.len() == 0 {
200 vec![$crate::text::StyleTableEntry {
201 color: $crate::enums::Color::Black,
202 font: $crate::enums::Font::Helvetica,
203 size: $crate::app::font_size(),
204 attr: $crate::text::TextAttr::None,
205 bgcolor: $crate::enums::Color::Black,
206 }]
207 } else {
208 entries
209 };
210 let mut colors: Vec<u32> = vec![];
211 let mut fonts: Vec<i32> = vec![];
212 let mut sizes: Vec<i32> = vec![];
213 let mut attrs: Vec<u32> = vec![];
214 let mut bgcols: Vec<u32> = vec![];
215 for entry in entries.iter() {
216 colors.push(entry.color.bits() as u32);
217 fonts.push(entry.font.bits() as i32);
218 sizes.push(entry.size as i32);
219 attrs.push(entry.attr as u32);
220 bgcols.push(entry.bgcolor.bits() as u32);
221 }
222 let style_buffer = style_buffer.into();
223 if let Some(style_buffer) = style_buffer {
224 let _old_buf = self.style_buffer();
225 unsafe {
226 [<$flname _set_highlight_data>](
227 self.inner.widget() as _,
228 style_buffer.as_ptr() as *mut raw::c_void,
229 colors.as_mut_ptr(),
230 fonts.as_mut_ptr(),
231 sizes.as_mut_ptr(),
232 attrs.as_mut_ptr(),
233 bgcols.as_mut_ptr(),
234 entries.len() as i32,
235 )
236 }
237 } else {
238 if let Some(buf) = self.style_buffer() {
239 unsafe {
240 [<$flname _set_highlight_data>](
241 self.inner.widget() as _,
242 buf.as_ptr() as _,
243 colors.as_mut_ptr(),
244 fonts.as_mut_ptr(),
245 sizes.as_mut_ptr(),
246 attrs.as_mut_ptr(),
247 bgcols.as_mut_ptr(),
248 1,
249 )
250 }
251 }
252 }
253 }
254
255 fn unset_highlight_data<B: Into<Option<$crate::text::TextBuffer>>>(&mut self, style_buffer: B) {
256 unsafe {
257 let mut colors = [$crate::enums::Color::Black.bits()];
258 let mut fonts = [$crate::enums::Font::Helvetica.bits()];
259 let mut sizes = [14];
260 let mut attrs = [0];
261 let mut bgcols = [0];
262 if let Some(style_buffer) = style_buffer.into() {
263 [<$flname _set_highlight_data>](
264 self.inner.widget() as _,
265 style_buffer.as_ptr() as *mut raw::c_void,
266 colors.as_mut_ptr(),
267 fonts.as_mut_ptr(),
268 sizes.as_mut_ptr(),
269 attrs.as_mut_ptr(),
270 bgcols.as_mut_ptr(),
271 1,
272 )
273 }
274 }
275 }
276
277 fn set_cursor_style(&mut self, style: $crate::text::Cursor) {
278 unsafe {
279 [<$flname _set_cursor_style>](self.inner.widget() as _, style as i32)
280 }
281 }
282
283 fn set_cursor_color(&mut self, color: $crate::enums::Color) {
284 unsafe {
285 [<$flname _set_cursor_color>](self.inner.widget() as _, color.bits() as u32)
286 }
287 }
288
289 fn set_scrollbar_size(&mut self, size: i32) {
290 unsafe {
291 [<$flname _set_scrollbar_size>](self.inner.widget() as _, size as i32)
292 }
293 }
294
295 fn set_scrollbar_align(&mut self, align: $crate::enums::Align) {
296 unsafe {
297 [<$flname _set_scrollbar_align>](self.inner.widget() as _, align.bits() as i32)
298 }
299 }
300
301 fn cursor_style(&self) -> $crate::text::Cursor {
302 unsafe {
303 std::mem::transmute([<$flname _cursor_style>](self.inner.widget() as _))
304 }
305 }
306
307 fn cursor_color(&self) -> $crate::enums::Color {
308 unsafe {
309 std::mem::transmute([<$flname _cursor_color>](self.inner.widget() as _))
310 }
311 }
312
313 fn scrollbar_size(&self) -> i32 {
314 unsafe {
315 [<$flname _scrollbar_size>](self.inner.widget() as _) as i32
316 }
317 }
318
319 fn scrollbar_align(&self) -> $crate::enums::Align {
320 unsafe {
321 std::mem::transmute([<$flname _scrollbar_align>](self.inner.widget() as _))
322 }
323 }
324
325 fn line_start(&self, pos: i32) -> i32 {
326 unsafe {
327 assert!(self.has_buffer());
328 [<$flname _line_start>](self.inner.widget() as _, pos as i32) as i32
329 }
330 }
331
332 fn line_end(&self, start_pos: i32, is_line_start: bool) -> i32 {
333 unsafe {
334 assert!(self.has_buffer());
335 [<$flname _line_end>](
336 self.inner.widget() as _,
337 start_pos as i32,
338 is_line_start as i32,
339 ) as i32
340 }
341 }
342
343 fn skip_lines(&mut self, start_pos: i32, lines: i32, is_line_start: bool) -> i32 {
344 unsafe {
345 assert!(self.has_buffer());
346 [<$flname _skip_lines>](
347 self.inner.widget() as _,
348 start_pos as i32,
349 lines as i32,
350 is_line_start as i32,
351 ) as i32
352 }
353 }
354
355 fn rewind_lines(&mut self, start_pos: i32, lines: i32) -> i32 {
356 unsafe {
357 assert!(self.has_buffer());
358 [<$flname _rewind_lines>](
359 self.inner.widget() as _,
360 start_pos as i32,
361 lines as i32,
362 ) as i32
363 }
364 }
365
366 fn next_word(&mut self) {
367 unsafe {
368 assert!(self.has_buffer());
369 [<$flname _next_word>](self.inner.widget() as _)
370 }
371 }
372
373 fn previous_word(&mut self) {
374 unsafe {
375 assert!(self.has_buffer());
376 [<$flname _previous_word>](self.inner.widget() as _)
377 }
378 }
379
380 fn word_start(&self, pos: i32) -> i32 {
381 unsafe {
382 assert!(self.has_buffer());
383 [<$flname _word_start>](self.inner.widget() as _, pos as i32) as i32
384 }
385 }
386
387 fn word_end(&self, pos: i32) -> i32 {
388 unsafe {
389 assert!(self.has_buffer());
390 [<$flname _word_end>](self.inner.widget() as _, pos as i32) as i32
391 }
392 }
393
394 fn x_to_col(&self, x: f64) -> f64 {
395 unsafe {
396 assert!(self.has_buffer());
397 [<$flname _x_to_col>](self.inner.widget() as _, x)
398 }
399 }
400
401 fn col_to_x(&self, col: f64) -> f64 {
402 unsafe {
403 assert!(self.has_buffer());
404 [<$flname _col_to_x>](self.inner.widget() as _, col)
405 }
406 }
407
408 fn set_linenumber_width(&mut self, w: i32) {
409 unsafe {
410 [<$flname _set_linenumber_width>](self.inner.widget() as _, w)
411 }
412 }
413
414 fn linenumber_width(&self) -> i32 {
415 unsafe {
416 [<$flname _linenumber_width>](self.inner.widget() as _)
417 }
418 }
419
420 fn set_linenumber_font(&mut self, font: $crate::enums::Font) {
421 unsafe {
422 [<$flname _set_linenumber_font>](self.inner.widget() as _, font.bits() as i32)
423 }
424 }
425
426 fn linenumber_font(&self) -> $crate::enums::Font {
427 unsafe {
428 std::mem::transmute([<$flname _linenumber_font>](self.inner.widget() as _))
429 }
430 }
431
432 fn set_linenumber_size(&mut self, size: i32) {
433 unsafe {
434 [<$flname _set_linenumber_size>](self.inner.widget() as _, size as i32)
435 }
436 }
437
438 fn linenumber_size(&self) -> i32 {
439 unsafe {
440 [<$flname _linenumber_size>](self.inner.widget() as _) as i32
441 }
442 }
443
444 fn set_linenumber_fgcolor(&mut self, color: $crate::enums::Color) {
445 unsafe {
446 [<$flname _set_linenumber_fgcolor>](
447 self.inner.widget() as _,
448 color.bits() as u32,
449 )
450 }
451 }
452
453 fn linenumber_fgcolor(&self) -> $crate::enums::Color {
454 unsafe {
455 std::mem::transmute([<$flname _linenumber_fgcolor>](self.inner.widget() as _))
456 }
457 }
458
459 fn set_linenumber_bgcolor(&mut self, color: $crate::enums::Color) {
460 unsafe {
461 [<$flname _set_linenumber_bgcolor>](
462 self.inner.widget() as _,
463 color.bits() as u32,
464 )
465 }
466 }
467
468 fn linenumber_bgcolor(&self) -> $crate::enums::Color {
469 unsafe {
470 std::mem::transmute([<$flname _linenumber_bgcolor>](self.inner.widget() as _))
471 }
472 }
473
474 fn set_linenumber_align(&mut self, align: $crate::enums::Align) {
475 unsafe {
476 [<$flname _set_linenumber_align>](self.inner.widget() as _, align.bits() as i32)
477 }
478 }
479
480 fn linenumber_align(&self) -> $crate::enums::Align {
481 unsafe {
482 std::mem::transmute([<$flname _linenumber_align>](self.inner.widget() as _))
483 }
484 }
485
486 fn in_selection(&self, x: i32, y: i32) -> bool {
487 unsafe {
488 assert!(self.has_buffer());
489 [<$flname _in_selection>](self.inner.widget() as _, x, y) != 0
490 }
491 }
492
493 fn wrap_mode(&mut self, wrap: $crate::text::WrapMode, wrap_margin: i32) {
494 unsafe { [<$flname _wrap_mode>](self.inner.widget() as _, wrap as i32, wrap_margin) }
495 }
496
497 fn wrapped_column(&self, row: i32, column: i32) -> i32 {
498 assert!(self.has_buffer());
499 unsafe { [<$flname _wrapped_column>](self.inner.widget() as _, row, column) }
500 }
501
502 fn wrapped_row(&self, row: i32) -> i32 {
503 assert!(self.has_buffer());
504 unsafe { [<$flname _wrapped_row>](self.inner.widget() as _, row) }
505 }
506
507 fn set_grammar_underline_color(&mut self, color: $crate::enums::Color) {
508 unsafe {
509 [<$flname _set_grammar_underline_color>](self.inner.widget() as _, color.bits() as u32)
510 }
511 }
512
513 fn grammar_underline_color(&self) -> $crate::enums::Color {
514 unsafe {
515 std::mem::transmute([<$flname _grammar_underline_color>](self.inner.widget() as _))
516 }
517 }
518
519 fn set_spelling_underline_color(&mut self, color: $crate::enums::Color) {
520 unsafe {
521 [<$flname _set_spelling_underline_color>](self.inner.widget() as _, color.bits() as u32)
522 }
523 }
524
525 fn spelling_underline_color(&self) -> $crate::enums::Color {
526 unsafe {
527 std::mem::transmute([<$flname _spelling_underline_color>](self.inner.widget() as _))
528 }
529 }
530
531 fn set_secondary_selection_color(&mut self, color: $crate::enums::Color) {
532 unsafe {
533 [<$flname _set_secondary_selection_color>](self.inner.widget() as _, color.bits() as u32)
534 }
535 }
536
537 fn secondary_selection_color(&self) -> $crate::enums::Color {
538 unsafe {
539 std::mem::transmute([<$flname _secondary_selection_color>](self.inner.widget() as _))
540 }
541 }
542 fn show_insert_position(&mut self) {
543 unsafe {
544 [<$flname _show_insert_position>](self.inner.widget() as _);
545 }
546 }
547 }
548 }
549 };
550}
551
552pub use impl_display_ext;