1#[doc(hidden)]
2#[macro_export]
3macro_rules! impl_table_ext {
5 ($name: ident, $flname: ident) => {
6 paste::paste! {
7 unsafe impl TableExt for $name {
8 fn clear(&mut self) {
9 unsafe {
10 [<$flname _clear>](self.inner.widget() as _)
11 }
12 }
13
14 fn set_table_frame(&mut self, frame: $crate::enums::FrameType) {
15 unsafe {
16 [<$flname _set_table_box>](self.inner.widget() as _, frame.as_i32())
17 }
18 }
19
20 fn table_frame(&self) -> $crate::enums::FrameType {
21 unsafe { $crate::enums::FrameType::from_i32([<$flname _table_box>](self.inner.widget() as _)) }
22 }
23
24 fn set_rows(&mut self, val: i32) {
25 unsafe {
26 [<$flname _set_rows>](self.inner.widget() as _, val as i32)
27 }
28 }
29
30 fn rows(&self) -> i32 {
31 unsafe {
32 [<$flname _rows>](self.inner.widget() as _) as i32
33 }
34 }
35
36 fn set_cols(&mut self, val: i32) {
37 unsafe {
38 [<$flname _set_cols>](self.inner.widget() as _, val as i32)
39 }
40 }
41
42 fn cols(&self) -> i32 {
43 unsafe {
44 [<$flname _cols>](self.inner.widget() as _) as i32
45 }
46 }
47
48 fn visible_cells(&self) -> Option<(i32, i32, i32, i32)> {
49 let (a, b, c, d) = unsafe {
50 let mut row_top = 0;
51 let mut col_left = 0;
52 let mut row_bot = 0;
53 let mut col_right = 0;
54 [<$flname _visible_cells>](
55 self.inner.widget() as _,
56 &mut row_top,
57 &mut col_left,
58 &mut row_bot,
59 &mut col_right,
60 );
61 (row_top, col_left, row_bot, col_right)
62 };
63 if a == -1 || b == -1 || c == -1 || d == -1 {
64 None
65 } else {
66 Some((a, b, c, d))
67 }
68 }
69
70 fn is_interactive_resize(&self) -> bool {
71 unsafe {
72 [<$flname _is_interactive_resize>](self.inner.widget() as _) != 0
73 }
74 }
75
76 fn row_resize(&self) -> bool {
77 unsafe {
78 [<$flname _row_resize>](self.inner.widget() as _) != 0
79 }
80 }
81
82 fn set_row_resize(&mut self, flag: bool) {
83 unsafe {
84 [<$flname _set_row_resize>](self.inner.widget() as _, i32::from(flag))
85 }
86 }
87
88 fn col_resize(&self) -> bool {
89 unsafe {
90 [<$flname _col_resize>](self.inner.widget() as _) != 0
91 }
92 }
93
94 fn set_col_resize(&mut self, flag: bool) {
95 unsafe {
96 [<$flname _set_col_resize>](self.inner.widget() as _, i32::from(flag))
97 }
98 }
99
100 fn col_resize_min(&self) -> i32 {
101 unsafe {
102 [<$flname _col_resize_min>](self.inner.widget() as _) as i32
103 }
104 }
105
106 fn set_col_resize_min(&mut self, val: i32) {
107 unsafe {
108 [<$flname _set_col_resize_min>](self.inner.widget() as _, val as i32)
109 }
110 }
111
112 fn row_resize_min(&self) -> i32 {
113 unsafe {
114 [<$flname _row_resize_min>](self.inner.widget() as _) as i32
115 }
116 }
117
118 fn set_row_resize_min(&mut self, val: i32) {
119 unsafe {
120 [<$flname _set_row_resize_min>](self.inner.widget() as _, val as i32)
121 }
122 }
123
124 fn row_header(&self) -> bool {
125 unsafe {
126 [<$flname _row_header>](self.inner.widget() as _) != 0
127 }
128 }
129
130 fn set_row_header(&mut self, flag: bool) {
131 unsafe {
132 [<$flname _set_row_header>](self.inner.widget() as _, i32::from(flag))
133 }
134 }
135
136 fn col_header(&self) -> bool {
137 unsafe {
138 [<$flname _col_header>](self.inner.widget() as _) != 0
139 }
140 }
141
142 fn set_col_header(&mut self, flag: bool) {
143 unsafe {
144 [<$flname _set_col_header>](self.inner.widget() as _, i32::from(flag))
145 }
146 }
147
148 fn set_col_header_height(&mut self, height: i32) {
149 unsafe {
150 [<$flname _set_col_header_height>](self.inner.widget() as _, height)
151 }
152 }
153
154 fn col_header_height(&self) -> i32 {
155 unsafe {
156 [<$flname _col_header_height>](self.inner.widget() as _)
157 }
158 }
159
160 fn set_row_header_width(&mut self, width: i32) {
161 unsafe {
162 [<$flname _set_row_header_width>](self.inner.widget() as _, width)
163 }
164 }
165
166 fn row_header_width(&self) -> i32 {
167 unsafe {
168 [<$flname _row_header_width>](self.inner.widget() as _)
169 }
170 }
171
172 fn set_row_header_color(&mut self, val: $crate::enums::Color) {
173 unsafe {
174 [<$flname _set_row_header_color>](self.inner.widget() as _, val.bits() as u32)
175 }
176 }
177
178 fn row_header_color(&self) -> $crate::enums::Color {
179 unsafe {
180 std::mem::transmute([<$flname _row_header_color>](self.inner.widget() as _))
181 }
182 }
183
184 fn set_col_header_color(&mut self, val: $crate::enums::Color) {
185 unsafe {
186 [<$flname _set_col_header_color>](self.inner.widget() as _, val.bits() as u32)
187 }
188 }
189
190 fn col_header_color(&self) -> $crate::enums::Color {
191 unsafe {
192 std::mem::transmute([<$flname _col_header_color>](self.inner.widget() as _))
193 }
194 }
195
196 fn set_row_height(&mut self, row: i32, height: i32) {
197 unsafe {
198 [<$flname _set_row_height>](self.inner.widget() as _, row, height)
199 }
200 }
201
202 fn row_height(&self, row: i32) -> i32 {
203 unsafe {
204 [<$flname _row_height>](self.inner.widget() as _, row)
205 }
206 }
207
208 fn set_col_width(&mut self, col: i32, width: i32) {
209 unsafe {
210 [<$flname _set_col_width>](self.inner.widget() as _, col, width)
211 }
212 }
213
214 fn col_width(&self, col: i32) -> i32 {
215 unsafe {
216 [<$flname _col_width>](self.inner.widget() as _, col)
217 }
218 }
219
220 fn set_row_height_all(&mut self, height: i32) {
221 unsafe {
222 [<$flname _set_row_height_all>](self.inner.widget() as _, height)
223 }
224 }
225
226 fn set_col_width_all(&mut self, width: i32) {
227 unsafe {
228 [<$flname _set_col_width_all>](self.inner.widget() as _, width)
229 }
230 }
231
232 fn set_row_position(&mut self, row: i32) {
233 unsafe {
234 [<$flname _set_row_position>](self.inner.widget() as _, row as i32)
235 }
236 }
237
238 fn set_col_position(&mut self, col: i32) {
239 unsafe {
240 [<$flname _set_col_position>](self.inner.widget() as _, col as i32)
241 }
242 }
243
244 fn row_position(&self) -> i32 {
245 unsafe {
246 [<$flname _row_position>](self.inner.widget() as _) as i32
247 }
248 }
249
250 fn col_position(&self) -> i32 {
251 unsafe {
252 [<$flname _col_position>](self.inner.widget() as _) as i32
253 }
254 }
255
256 fn set_top_row(&mut self, row: i32) {
257 unsafe {
258 [<$flname _set_top_row>](self.inner.widget() as _, row as i32)
259 }
260 }
261
262 fn top_row(&self) -> i32 {
263 unsafe {
264 [<$flname _top_row>](self.inner.widget() as _) as i32
265 }
266 }
267
268 fn is_selected(&self, r: i32, c: i32) -> bool {
269 unsafe {
270 [<$flname _is_selected>](self.inner.widget() as _, r, c) != 0
271 }
272 }
273
274 fn get_selection(&self) -> Option<(i32, i32, i32, i32)> {
275 let (a, b, c, d) = unsafe {
276 let mut row_top = 0;
277 let mut col_left = 0;
278 let mut row_bot = 0;
279 let mut col_right = 0;
280 [<$flname _get_selection>](
281 self.inner.widget() as _,
282 &mut row_top,
283 &mut col_left,
284 &mut row_bot,
285 &mut col_right,
286 );
287 (row_top, col_left, row_bot, col_right)
288 };
289 if a < 0 && b < 0 && c >= 0 && d >= 0 {
290 Some((0, 0, c, d))
291 } else if a >= 0 && b >=0 && c >=0 && d >= 0 {
292 Some((a, b, c, d))
293 } else {
294 None
295 }
296 }
297
298 fn set_selection(&mut self, row_top: i32, col_left: i32, row_bot: i32, col_right: i32) {
299 unsafe {
300 [<$flname _set_selection>](
301 self.inner.widget() as _, row_top, col_left, row_bot, col_right,
302 )
303 }
304 }
305
306 fn unset_selection(&mut self) {
307 self.set_selection(-1, -1, -1, -1)
308 }
309
310 fn move_cursor_with_shift_select(
311 &mut self,
312 r: i32,
313 c: i32,
314 shiftselect: bool,
315 ) -> Result<(), FltkError> {
316 unsafe {
317 let x = [<$flname _move_cursor_with_shiftselect>](
318 self.inner.widget() as _,
319 r,
320 c,
321 shiftselect as i32,
322 );
323 if x == 0 {
324 return Err(FltkError::Internal(FltkErrorKind::FailedOperation));
325 }
326 Ok(())
327 }
328 }
329
330 fn move_cursor(&mut self, r: i32, c: i32) -> Result<(), FltkError> {
331 unsafe {
332 let x = [<$flname _move_cursor>](self.inner.widget() as _, r, c);
333 if x == 0 {
334 return Err(FltkError::Internal(FltkErrorKind::FailedOperation));
335 }
336 Ok(())
337 }
338 }
339
340 fn scrollbar_size(&self) -> i32 {
341 unsafe {
342 [<$flname _scrollbar_size>](self.inner.widget() as _) as i32
343 }
344 }
345
346 fn set_scrollbar_size(&mut self, new_size: i32) {
347 unsafe {
348 [<$flname _set_scrollbar_size>](self.inner.widget() as _, new_size as i32)
349 }
350 }
351
352 fn set_tab_cell_nav(&mut self, val: bool) {
353 unsafe {
354 [<$flname _set_tab_cell_nav>](self.inner.widget() as _, val as i32)
355 }
356 }
357
358 fn tab_cell_nav(&self) -> bool {
359 unsafe {
360 [<$flname _tab_cell_nav>](self.inner.widget() as _) != 0
361 }
362 }
363
364 fn draw_cell<
365 F: FnMut(&mut Self, $crate::table::TableContext, i32, i32, i32, i32, i32, i32)
366 + 'static,
367 >(
368 &mut self,
369 cb: F,
370 ) {
371 assert!(self.is_derived);
372 pub type CustomDrawCellCallback = Option<
373 unsafe extern "C" fn(
374 wid: *mut Fl_Widget,
375 ctx: std::os::raw::c_int,
376 arg2: std::os::raw::c_int,
377 arg3: std::os::raw::c_int,
378 arg4: std::os::raw::c_int,
379 arg5: std::os::raw::c_int,
380 arg6: std::os::raw::c_int,
381 arg7: std::os::raw::c_int,
382 data: *mut std::os::raw::c_void,
383 ),
384 >;
385 unsafe {
386 unsafe extern "C" fn shim(
387 wid: *mut Fl_Widget,
388 ctx: std::os::raw::c_int,
389 arg2: std::os::raw::c_int,
390 arg3: std::os::raw::c_int,
391 arg4: std::os::raw::c_int,
392 arg5: std::os::raw::c_int,
393 arg6: std::os::raw::c_int,
394 arg7: std::os::raw::c_int,
395 data: *mut std::os::raw::c_void,
396 ) { unsafe {
397 let mut wid = $name::from_widget_ptr(wid as *mut _);
398 wid.assume_derived();
399 let ctx: TableContext = std::mem::transmute(ctx);
400 let a: *mut Box<
401 dyn FnMut(
402 &mut $name,
403 $crate::table::TableContext,
404 i32,
405 i32,
406 i32,
407 i32,
408 i32,
409 i32,
410 ),
411 > = data as *mut Box<
412 dyn FnMut(
413 &mut $name,
414 $crate::table::TableContext,
415 i32,
416 i32,
417 i32,
418 i32,
419 i32,
420 i32,
421 ),
422 >;
423 let f: &mut (dyn FnMut(
424 &mut $name,
425 $crate::table::TableContext,
426 i32,
427 i32,
428 i32,
429 i32,
430 i32,
431 i32,
432 )) = &mut **a;
433 let _ = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
434 f(&mut wid, ctx, arg2, arg3, arg4, arg5, arg6, arg7)
435 }));
436 }}
437 let mut _old_data = None;
438 if self.is_derived {
439 _old_data = self.draw_cell_data();
440 }
441 let a: *mut Box<
442 dyn FnMut(
443 &mut Self,
444 $crate::table::TableContext,
445 i32,
446 i32,
447 i32,
448 i32,
449 i32,
450 i32,
451 ),
452 > = Box::into_raw(Box::new(Box::new(cb)));
453 let data: *mut std::os::raw::c_void = a as *mut std::os::raw::c_void;
454 let callback: CustomDrawCellCallback = Some(shim);
455 [<$flname _draw_cell>](self.inner.widget() as _, callback, data);
456 }
457 }
458
459 unsafe fn draw_cell_data(&self) -> Option<Box<dyn FnMut()>> { unsafe {
460 let ptr = [<$flname _draw_cell_data>](self.inner.widget() as _);
461 if ptr.is_null() {
462 None
463 } else {
464 let data = ptr as *mut Box<dyn FnMut()>;
465 let data = Box::from_raw(data);
466 Some(*data)
467 }
468 }}
469
470 fn callback_col(&self) -> i32 {
471 unsafe { [<$flname _callback_col>](self.inner.widget() as _) }
472 }
473
474 fn callback_row(&self) -> i32 {
475 unsafe { [<$flname _callback_row>](self.inner.widget() as _) }
476 }
477
478 fn callback_context(&self) -> TableContext {
479 unsafe { std::mem::transmute([<$flname _callback_context>](self.inner.widget() as _)) }
480 }
481
482 fn scrollbar(&self) -> $crate::valuator::Scrollbar {
483 unsafe {
484 let ptr = [<$flname _scrollbar>](self.inner.widget() as _);
485 assert!(!ptr.is_null());
486 $crate::valuator::Scrollbar::from_widget_ptr(
487 ptr as *mut fltk_sys::widget::Fl_Widget,
488 )
489 }
490 }
491
492 fn hscrollbar(&self) -> $crate::valuator::Scrollbar {
493 unsafe {
494 let ptr = [<$flname _hscrollbar>](self.inner.widget() as _);
495 assert!(!ptr.is_null());
496 $crate::valuator::Scrollbar::from_widget_ptr(
497 ptr as *mut fltk_sys::widget::Fl_Widget,
498 )
499 }
500 }
501
502 fn scroll(&self) -> Option<$crate::group::Scroll> {
503 unsafe {
504 let ptr = [<$flname _scroll>](self.inner.widget() as _);
505 if ptr.is_null() {
506 None
507 } else {
508 Some($crate::group::Scroll::from_widget_ptr(
509 ptr as *mut fltk_sys::widget::Fl_Widget,
510 ))
511 }
512 }
513 }
514
515 fn find_cell(
516 &self,
517 ctx: $crate::table::TableContext,
518 row: i32,
519 col: i32,
520 ) -> Option<(i32, i32, i32, i32)> {
521 let mut x = 0;
522 let mut y = 0;
523 let mut w = 0;
524 let mut h = 0;
525 unsafe {
526 let ret = [<$flname _find_cell>](self.inner.widget() as _, ctx as i32, row, col, &mut x, &mut y, &mut w, &mut h);
527 if ret == 0 {
528 Some((x, y, w, h))
529 } else {
530 None
531 }
532 }
533 }
534
535 fn cursor2rowcol(
536 &self,
537 ) -> Option<(
538 $crate::table::TableContext,
539 i32,
540 i32,
541 $crate::table::TableResizeFlag,
542 )> {
543 let mut r = 0;
544 let mut c = 0;
545 let mut flag = 0;
546 unsafe {
547 let ret = [<$flname _cursor2rowcol>](self.inner.widget() as _, &mut r, &mut c, &mut flag);
548 let ctx: $crate::table::TableContext = std::mem::transmute(ret);
549 if ctx == $crate::table::TableContext::None {
550 None
551 } else {
552 let flag: $crate::table::TableResizeFlag = std::mem::transmute(flag);
553 Some((ctx, r, c, flag))
554 }
555 }
556 }
557 }
558 }
559 };
560}
561
562pub use impl_table_ext;