tk 0.1.5

Rust bindings for Tk GUI library
Documentation 
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

use crate::{
    InterpResult,
    TkBBoxTrait,
    TkEntryTraits,
    TkInstance,
    TkXView,
    TtkCommonTraits,
    Widget,
    range::{
        TkDefaultEnd,
        TkDefaultStart,
        TkRange,
    },
    traits::Delete,
};

use std::{
    ops::{
        RangeFrom,
        RangeInclusive,
        RangeToInclusive,
    },
    os::raw::c_int,
};

use tcl::Obj;

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

#[derive( Clone )]
pub enum Index {
    Number( c_int ),
    At( c_int ),
    End,
    Insert,
    SelFirst,
    SelLast,
}

impl From<c_int> for Index {
    fn from( number: c_int ) -> Self { Index::Number( number )}
}

impl TkDefaultStart for Index {
    fn default_start() -> Self { Index::Number(0) }
}

impl TkDefaultEnd for Index {
    fn default_end() -> Self { Index::End }
}

impl From<RangeFrom<c_int>> for TkRange<Index> { // a..
    fn from( r: RangeFrom<c_int> ) -> Self {
        TkRange {
            start : Index::Number( r.start ),
            end   : Index::default_end()
        }
    }
}

impl From<RangeInclusive<c_int>> for TkRange<Index> { // a..=b
    fn from( r: RangeInclusive<c_int> ) -> Self {
        TkRange {
            start : Index::Number( *r.start() ),
            end   : Index::Number( *r.end() )
        }
    }
}

impl From<RangeToInclusive<c_int>> for TkRange<Index> { // ..=b
    fn from( r: RangeToInclusive<c_int> ) -> Self {
        TkRange {
            start : Index::default_start(),
            end   : Index::Number( r.end ),
        }
    }
}

impl From<Index> for Obj {
    fn from( index: Index ) -> Obj {
        use Index::*;
        match index {
            Number( n ) => n                  .into(),
            At( n )     => format!( "@{}", n ).into(),
            End         => "end"              .into(),
            Insert      => "insert"           .into(),
            SelFirst    => "sel.first"        .into(),
            SelLast     => "sel.last"         .into(),
        }
    }
}

impl<Inst:TkInstance> TtkEntry<Inst> {
    pub fn icursor( &self, index: impl Into<Index> ) -> InterpResult<()> {
        self.0.tk().run(( self.0.path, "icursor", index.into() ))
    }

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

impl<Inst:TkInstance> TtkCommonTraits<Inst> for TtkEntry<Inst> {}

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

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

impl<Inst:TkInstance> TkEntryTraits<Inst> for TtkEntry<Inst> {
    type Index = Index;
}

impl<Inst:TkInstance> TkXView<Inst> for TtkEntry<Inst> {
    type Index = Index;
}