tk 0.1.10

Rust bindings for Tk GUI library
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163

use enumx::export::*;
use enumx::predefined::*;
use cex::*;

use crate::{
    InterpResult,
    TkInstance,
    Widget,
    entry::Index,
    error::TkSpinboxElementParseError,
    traits::Delete,
};

use std::os::raw::{
    c_double,
    c_int,
};

use tcl::{
    Obj,
    error::{
        DeError,
        InterpError,
    },
    from_obj,
};

#[derive( Copy, Clone )]
pub struct TkSpinbox<Inst:TkInstance>( pub(crate) Widget<Inst> );

#[derive( Debug )]
pub enum TkSpinboxElement {
    None, ButtonDown, ButtonUp, Entry,
}

#[derive( Debug )]
pub enum TkSpinboxInvokableElement {
    ButtonDown, ButtonUp,
}

impl From<TkSpinboxInvokableElement> for Obj {
    fn from( element: TkSpinboxInvokableElement ) -> Obj {
        match element {
            TkSpinboxInvokableElement::ButtonDown => "buttondown".into(),
            TkSpinboxInvokableElement::ButtonUp   => "buttonup"  .into(),
        }
    }
}

impl<Inst:TkInstance> TkSpinbox<Inst> {
    pub fn get( &self ) -> InterpResult<String> {
        self.tk().eval(( self.0.path, "get" )).map( |obj| obj.to_string() )
    }

    pub fn icursor( &self, index: Index ) -> InterpResult<()> {
        self.tk().run(( self.0.path, "icursor", index ))
    }

    #[cex]
    pub fn identify( &self, x: c_int, y: c_int )
        -> Result!( Option<TkSpinboxElement> throws InterpError, TkSpinboxElementParseError )
    {
        let obj = self.tk().eval(( self.path, "identify", x, y ))?;
        let s = obj.to_string();
        ret!( match s.as_str() {
            "none"       => Some( TkSpinboxElement::None       ),
            "buttondown" => Some( TkSpinboxElement::ButtonDown ),
            "buttonup"   => Some( TkSpinboxElement::ButtonUp   ),
            "entry"      => Some( TkSpinboxElement::Entry      ),
            ""           => None,
            _            => throw!( TkSpinboxElementParseError( s )),
        })
    }

    pub fn index( &self, index: Index ) -> InterpResult<c_int> {
        let int = self.tk().eval(( self.0.path, "index", index ))?;
        self.tk().int( int )
    }

    pub fn insert( &self, index: Index, string: &str ) -> InterpResult<()> {
        self.tk().run(( self.0.path, "insert", index, string ))
    }

    pub fn invoke( &self, element: TkSpinboxInvokableElement ) -> InterpResult<()> {
        self.tk().run(( self.0.path, "invoke", element ))
    }

    pub fn scan_mark( &self, x: Index ) -> InterpResult<()> {
        self.tk().run(( self.0.path, "scan", "mark", x ))
    }

    pub fn scan_dragto( &self, x: Index ) -> InterpResult<()> {
        self.tk().run(( self.0.path, "scan", "dragto", x ))
    }

    pub fn selection_adjust( &self, index: Index ) -> InterpResult<()> {
        self.tk().run(( self.0.path, "selection", "adjust", index ))
    }

    pub fn selection_clear( &self ) -> InterpResult<()> {
        self.tk().run(( self.0.path, "selection", "clear" ))
    }

    pub fn selection_element( &self,  ) -> InterpResult<()> {
        self.tk().run(( self.0.path, "selection", "clear" ))
    }

    pub fn selection_from( &self, index: Index ) -> InterpResult<()> {
        self.tk().run(( self.0.path, "selection", "from", index ))
    }

    pub fn selection_present( &self ) -> InterpResult<bool> {
        let boolean = self.tk().eval(( self.0.path, "selection", "present" ))?;
        self.tk().boolean( boolean )
    }

    pub fn selection_range( &self, start: Index, end: Index ) -> InterpResult<()> {
        self.tk().run(( self.0.path, "selection", "range", start, end ))
    }

    pub fn selection_to( &self, index: Index ) -> InterpResult<()> {
        self.tk().run(( self.0.path, "selection", "to", index ))
    }

    pub fn set( &self, value: &str ) -> InterpResult<()> {
        self.tk().run(( self.0.path, "set", value ))
    }

    pub fn validate( &self ) -> InterpResult<bool> {
        let boolean = self.tk().eval(( self.0.path, "validate" ))?;
        self.tk().boolean( boolean )
    }

    #[cex]
    pub fn xview( &self ) -> Result!( (c_double, c_double) throws DeError, InterpError ) {
        let obj = self.tk().eval(( self.0.path, "xview" ))?;
        ret!( from_obj::<(c_double, c_double)>( obj ));
    }

    pub fn xview_index( &self, index: Index ) -> InterpResult<()> {
        self.tk().run(( self.0.path, "xview", index ))
    }

    pub fn xview_moveto( &self, fraction: c_double ) -> InterpResult<()> {
        self.tk().run(( self.0.path, "xview", "moveto", fraction ))
    }

    pub fn xview_scroll_units( &self, number: c_double ) -> InterpResult<()> {
        self.tk().run(( self.0.path, "xview", "scroll", number, "units" ))
    }

    pub fn xview_scroll_pages( &self, number: c_double ) -> InterpResult<()> {
        self.tk().run(( self.0.path, "xview", "scroll", number, "pages" ))
    }
}

impl<Inst:TkInstance> crate::TkBBoxTrait<Inst> for TkSpinbox<Inst> {
    type Index = Index;
}

impl<Inst:TkInstance> Delete<Inst> for TkSpinbox<Inst> {
    type Index = Index;
}