1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

use crate::utils::get_fl_name;
use proc_macro::TokenStream;
use quote::*;
use syn::*;

pub fn impl_button_trait(ast: &DeriveInput) -> TokenStream {
    let name = &ast.ident;

    let name_str = get_fl_name(name.to_string());

    let shortcut = Ident::new(format!("{}_{}", name_str, "shortcut").as_str(), name.span());
    let set_shortcut = Ident::new(
        format!("{}_{}", name_str, "set_shortcut").as_str(),
        name.span(),
    );
    let clear = Ident::new(format!("{}_{}", name_str, "clear").as_str(), name.span());
    let value = Ident::new(format!("{}_{}", name_str, "value").as_str(), name.span());
    let set_value = Ident::new(
        format!("{}_{}", name_str, "set_value").as_str(),
        name.span(),
    );
    let down_box = Ident::new(format!("{}_{}", name_str, "down_box").as_str(), name.span());
    let set_down_box = Ident::new(
        format!("{}_{}", name_str, "set_down_box").as_str(),
        name.span(),
    );

    let gen = quote! {
        unsafe impl ButtonExt for #name {
            fn shortcut(&self) -> Shortcut {
                unsafe {
                    assert!(!self.was_deleted());
                    mem::transmute(#shortcut(self.inner))
                }
            }

            fn set_shortcut(&mut self, shortcut: Shortcut) {
                unsafe {
                    assert!(!self.was_deleted());
                    #set_shortcut(self.inner, shortcut.bits() as i32)
                }
            }

            fn clear(&mut self) {
                unsafe {
                    assert!(!self.was_deleted());
                    #clear(self.inner);
                }
            }

            fn is_set(&self) -> bool {
                unsafe {
                    assert!(!self.was_deleted());
                    #value(self.inner)  != 0
                }
            }

            fn set(&mut self, flag: bool) {
                unsafe {
                    assert!(!self.was_deleted());
                    #set_value(self.inner, flag as i32)
                }
            }

            fn value(&self) -> bool {
                unsafe {
                    assert!(!self.was_deleted());
                    #value(self.inner)  != 0
                }
            }

            fn set_value(&mut self, flag: bool) {
                unsafe {
                    assert!(!self.was_deleted());
                    #set_value(self.inner, flag as i32)
                }
            }

            fn set_down_frame(&mut self, f: FrameType) {
                assert!(!self.was_deleted());
                unsafe {
                    #set_down_box(self.inner, f as i32)
                }
            }

            fn down_frame(&self) -> FrameType {
                assert!(!self.was_deleted());
                unsafe {
                    mem::transmute(#down_box(self.inner))
                }
            }
        }
    };
    gen.into()
}