← Back to branch summary

~maliit-team/maliit-plugin-jp/trunk

« back to all changes in this revision

Viewing changes to src/maliit/qml/Keyboard.qml

  • Committer: liang
  • Date: 2011-07-20 17:19:53 UTC
  • Revision ID: git-v1:c3d107a6b280a8d2c071bb1df794c7b0a4d4c703
package done

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/maliit/qml/Keyboard.qml
 
1
import Qt 4.7
 
2
import "utils.js" as Utils
 
3
 
 
4
Rectangle {
 
5
    id : keyboard
 
6
    clip : true
 
7
    color : "#FFDDDDDD"
 
8
    /*color : "#FF000000"*/
 
9
 
 
10
    property int keyWidth : width / 10.5
 
11
    property int keyHeight : 60
 
12
    property int numKeyWidth : ( width - ( keyWidth * 1.1 ) ) / 10
 
13
    property int numKeyHeight : 60 
 
14
 
 
15
    property bool useIKey_l : true
 
16
    property Item pressedKey
 
17
    property alias backspaceKey : key_backspace
 
18
 
 
19
    /*keyWidth : 800 / 10 * 1.010*/
 
20
    /*keyHeight : keyWidth * 0.975*/
 
21
 
 
22
    property int mask : 0
 
23
    property int mode : 0
 
24
 
 
25
    function updateCandString() {
 
26
        engine.updateCandidate( 0 )
 
27
        key_5_6.candString = engine.getWord()
 
28
 
 
29
        preedit.preeditCode = engine.getPreeditCode()
 
30
        preedit.invaildCode = engine.getInvalidCode()
 
31
        preedit.selectedWord = engine.getSelectedWord()
 
32
 
 
33
        engine.updateCandidate( 1 )
 
34
        key_3_4.candString = engine.getWord()
 
35
        engine.updateCandidate( 2 )
 
36
        key_7_8.candString = engine.getWord()
 
37
        engine.updateCandidate( 3 )
 
38
        key_9_0.candString = engine.getWord()
 
39
        engine.updateCandidate( 4 )
 
40
        key_1_2.candString = engine.getWord()
 
41
    }
 
42
    function commit() {
 
43
        /*console.log( inputmethod.cursorRect.x, inputmethod.cursorRect.y, inputmethod.cursorRect.width, inputmethod.cursorRect.height)*/
 
44
        inputmethod.sendCommit( engine.getSelectedWord() )
 
45
        engine.commit()
 
46
    }
 
47
    property bool needClearShift : false
 
48
    property bool needClearAlt : false
 
49
    function keyPress( key ) {
 
50
        var keycode = key.keycode
 
51
        if ( keycode == Utils.keycode_space ) {
 
52
            if ( engine.getCodeLength() <= 0 ) {
 
53
                if ( mask == Utils.keymask_null ) {
 
54
                    clearMask()
 
55
                    key_space.keepDown = true
 
56
                    mask = Utils.keymask_space
 
57
                }
 
58
            }
 
59
        }
 
60
        else if ( keycode == Utils.keycode_shift_l || keycode == Utils.keycode_shift_r ) {
 
61
            if ( engine.getCodeLength() <= 0 ) {
 
62
                if ( mask != Utils.keymask_shift ) {
 
63
                    clearMask()
 
64
                    key_shift_l.keepDown = true
 
65
                    key_shift_r.keepDown = true
 
66
                    mask = Utils.keymask_shift
 
67
                }
 
68
                else
 
69
                    needClearShift = true
 
70
            }
 
71
        }
 
72
        else if ( keycode == Utils.keycode_alt_l || keycode == Utils.keycode_alt_r ) {
 
73
            if ( engine.getCodeLength() <= 0 ) {
 
74
                if ( mask != Utils.keymask_alt ) {
 
75
                    clearMask()
 
76
                    key_alt_l.keepDown = true
 
77
                    key_alt_r.keepDown = true
 
78
                    mask = Utils.keymask_alt
 
79
                }
 
80
                else
 
81
                    needClearAlt = true
 
82
            }
 
83
        }
 
84
        moveTooltip( key )
 
85
    }
 
86
    function clearMask() {
 
87
        key_alt_l.keepDown = false
 
88
        key_alt_r.keepDown = false
 
89
        key_shift_l.keepDown = false
 
90
        key_shift_r.keepDown = false
 
91
        key_space.keepDown = false
 
92
        mask = Utils.keymask_null
 
93
        needClearAlt = false
 
94
        needClearShift = false
 
95
    }
 
96
    function switchMode() {
 
97
        if ( mode == Utils.mode_CN ) {
 
98
            if ( engine.getCodeLength() <= 0 ) {
 
99
                mode = Utils.mode_EN 
 
100
            }
 
101
        }
 
102
        else if ( mode == Utils.mode_EN ) {
 
103
            mode = Utils.mode_CN 
 
104
        }
 
105
    }
 
106
    function backspace() {
 
107
        if ( !key_backspace.paused ) {
 
108
            if ( engine.getSelectedWordLength() > 0 ) {
 
109
                engine.deselect()
 
110
                updateCandString()
 
111
            }
 
112
            else if ( engine.getCodeLength() > 0 ) {
 
113
                engine.popCode()
 
114
                updateCandString()
 
115
                if ( engine.getCodeLength() <= 0 ) 
 
116
                    key_backspace.pauseAutoRepeat()
 
117
            }
 
118
            else {
 
119
                inputmethod.sendCommit( "\b" )
 
120
            }
 
121
        }
 
122
    }
 
123
    function keyRelease( key ) {
 
124
        var keycode = key.keycode
 
125
        var keysym = Utils.keysym[mode][keycode]
 
126
        if ( keycode >= Utils.keycode_a && keycode <= Utils.keycode_z && mask == Utils.keymask_null ) {
 
127
            /*engine.appendCode( keysym[mask][mode] )*/
 
128
            if ( mode == Utils.mode_CN ) {
 
129
                engine.appendCode( keysym[mask] )
 
130
                updateCandString()
 
131
            }
 
132
            else {
 
133
                inputmethod.sendCommit( keysym[mask] )
 
134
            }
 
135
        }
 
136
        else if ( keycode == Utils.keycode_backspace ) {
 
137
            backspace()
 
138
        }
 
139
        else if ( keycode == Utils.keycode_shift_l ) {
 
140
            if ( engine.getCodeLength() > 0 ) {
 
141
                engine.prevPage( 5 )
 
142
                updateCandString()
 
143
            }
 
144
        }
 
145
        else if ( keycode == Utils.keycode_shift_r ) {
 
146
            if ( engine.getCodeLength() > 0 ) {
 
147
                engine.nextPage( 5 )
 
148
                updateCandString()
 
149
            }
 
150
        }
 
151
        else if ( keycode == Utils.keycode_alt_l ) {
 
152
            if ( engine.getCodeLength() > 0 ) {
 
153
                engine.prevPage( 5 )
 
154
                updateCandString()
 
155
            }
 
156
        }
 
157
        else if ( keycode == Utils.keycode_alt_r ) {
 
158
            if ( engine.getCodeLength() > 0 ) {
 
159
                engine.nextPage( 5 )
 
160
                updateCandString()
 
161
            }
 
162
        }
 
163
        else if ( keycode == Utils.keycode_enter ) {
 
164
            if ( engine.getCodeLength() > 0 ) {
 
165
                inputmethod.sendCommit( engine.getCode() )
 
166
                engine.reset()
 
167
                updateCandString()
 
168
            }
 
169
            else {
 
170
                inputmethod.sendCommit( "\n" )
 
171
            }
 
172
        }
 
173
        else if ( keycode == Utils.keycode_space ) {
 
174
            if ( engine.getCodeLength() > 0 ) {
 
175
                engine.select( 0 )
 
176
                updateCandString()
 
177
                if ( engine.getCodeLength() <= 0 && engine.getInvalidCodeLength() <= 0 && engine.getSelectedWordLength() > 0 ) {
 
178
                    commit()
 
179
                    updateCandString()
 
180
                }
 
181
            }
 
182
            else {
 
183
                inputmethod.sendCommit( keysym[mask] )
 
184
            }
 
185
        }
 
186
        else if ( keycode >= Utils.keycode_0 && keycode <= Utils.keycode_9 ) {
 
187
            if ( engine.getCodeLength() > 0 ) {
 
188
                var index = keycode - Utils.keycode_0
 
189
                index = Utils.candIndex[index]
 
190
                engine.select( index )
 
191
                updateCandString()
 
192
                if ( engine.getCodeLength() <= 0 && engine.getInvalidCodeLength() <= 0 && engine.getSelectedWordLength() > 0 ) {
 
193
                    commit()
 
194
                    updateCandString()
 
195
                }
 
196
            }
 
197
            else {
 
198
                inputmethod.sendCommit( keysym[mask] )
 
199
            }
 
200
        }
 
201
        else if ( keycode != Utils.keycode_ctrl && keycode != Utils.keycode_alt_l && keycode != Utils.keycode_alt_r ) {
 
202
            inputmethod.sendCommit( keysym[mask] )
 
203
        }
 
204
        tooltip.text = ""
 
205
        if ( keycode == Utils.keycode_shift_l || keycode == Utils.keycode_shift_r ) {
 
206
            if ( needClearShift ) {
 
207
                clearMask()
 
208
                /*needClearShift = false*/
 
209
            }
 
210
            /*else*/
 
211
                /*needClearShift = true*/
 
212
        }
 
213
        else if ( keycode == Utils.keycode_alt_l || keycode == Utils.keycode_alt_r ) {
 
214
            if ( needClearAlt ) {
 
215
                clearMask()
 
216
                /*needClearAlt = false*/
 
217
            }
 
218
            /*else*/
 
219
                /*needClearAlt = true*/
 
220
        }
 
221
        else {
 
222
            clearMask()
 
223
            /*if ( !needClearAlt && !needClearShift ) {*/
 
224
                /*clearMask()*/
 
225
            /*}*/
 
226
        }
 
227
    }
 
228
    function keyExit( key ) {
 
229
        pressedKey = null
 
230
        tooltip.text = ""
 
231
        /*tooltip.visible = false*/
 
232
        /*console.log( "exit", key.keysym[0] )*/
 
233
    }
 
234
    function keyEnter( key ) {
 
235
        /*console.log( "enter", key.keysym[0] )*/
 
236
        pressedKey = key
 
237
        moveTooltip( key )
 
238
    }
 
239
    function moveTooltip( key ) {
 
240
        /*var keycode = key.keycode*/
 
241
        /*var keysym = Utils.keysym[keycode]*/
 
242
        if ( !key.keepDown ) {
 
243
            var parent = key.parent
 
244
            var pos = parent.mapToItem( tooltip.parent, key.x, key.y )
 
245
            var x = pos.x + key.width / 2 - tooltip.width / 2
 
246
            var y = pos.y - tooltip.height - keyHeight * 0.1
 
247
            if ( y < -10 ) {
 
248
                y = -10
 
249
            }
 
250
            tooltip.x = x
 
251
            tooltip.y = y
 
252
            
 
253
            tooltip.text = key.text
 
254
        }
 
255
        else {
 
256
            tooltip.text = ""
 
257
        }
 
258
    }
 
259
 
 
260
    /*RealMouseArea {*/
 
261
        /*anchors.fill : parent */
 
262
    Column {
 
263
        anchors.centerIn : parent
 
264
        Row {
 
265
            anchors.horizontalCenter : parent.horizontalCenter
 
266
            CandKey { id : key_1_2 ; keycode_l : Utils.keycode_1 ; keycode_r : Utils.keycode_2 ; width : numKeyWidth * 2.0 ; height : numKeyHeight }
 
267
            CandKey { id : key_3_4 ; keycode_l : Utils.keycode_3 ; keycode_r : Utils.keycode_4 ; width : numKeyWidth * 2.0 ; height : numKeyHeight }
 
268
            CandKey { id : key_5_6 ; keycode_l : Utils.keycode_5 ; keycode_r : Utils.keycode_6 ; width : numKeyWidth * 2.0 ; height : numKeyHeight }
 
269
            CandKey { id : key_7_8 ; keycode_l : Utils.keycode_7 ; keycode_r : Utils.keycode_8 ; width : numKeyWidth * 2.0 ; height : numKeyHeight }
 
270
            CandKey { id : key_9_0 ; keycode_l : Utils.keycode_9 ; keycode_r : Utils.keycode_0 ; width : numKeyWidth * 2.0 ; height : numKeyHeight }
 
271
            AutoRepeatKey { id : key_backspace ; keycode : Utils.keycode_backspace ; width : keyWidth * 1.1 ; height : numKeyHeight ; onRepeated : backspace() }
 
272
        }
 
273
        Row {
 
274
            anchors.horizontalCenter : parent.horizontalCenter
 
275
            /*Item { width : keyWidth * 0.25 ; height : keyHeight }*/
 
276
            ProxyMouseArea { id : ikey_q ; width : keyWidth * 0.1 ; height : keyHeight }
 
277
            Key { id : key_q ; keycode : Utils.keycode_q ; width : keyWidth ; height : keyHeight }
 
278
            Key { id : key_w ; keycode : Utils.keycode_w ; width : keyWidth ; height : keyHeight }
 
279
            Key { id : key_e ; keycode : Utils.keycode_e ; width : keyWidth ; height : keyHeight }
 
280
            Key { id : key_r ; keycode : Utils.keycode_r ; width : keyWidth ; height : keyHeight }
 
281
            Key { id : key_t ; keycode : Utils.keycode_t ; width : keyWidth ; height : keyHeight }
 
282
            Key { id : key_y ; keycode : Utils.keycode_y ; width : keyWidth ; height : keyHeight }
 
283
            Key { id : key_u ; keycode : Utils.keycode_u ; width : keyWidth ; height : keyHeight }
 
284
            Key { id : key_i ; keycode : Utils.keycode_i ; width : keyWidth ; height : keyHeight }
 
285
            Key { id : key_o ; keycode : Utils.keycode_o ; width : keyWidth ; height : keyHeight }
 
286
            Key { id : key_p ; keycode : Utils.keycode_p ; width : keyWidth ; height : keyHeight }
 
287
            ProxyMouseArea { id : ikey_p ; width : keyWidth * 0.5 ; height : keyHeight }
 
288
            /*ProxyMouseArea { id : ikey_backspace ; width : keyWidth ; height : keyHeight }*/
 
289
        }
 
290
        Row {
 
291
            anchors.horizontalCenter : parent.horizontalCenter
 
292
            ProxyMouseArea { id : ikey_a ; width : keyWidth * 0.3 ; height : keyHeight }
 
293
            Key { id : key_a ; keycode : Utils.keycode_a ; width : keyWidth ; height : keyHeight }
 
294
            Key { id : key_s ; keycode : Utils.keycode_s ; width : keyWidth ; height : keyHeight }
 
295
            Key { id : key_d ; keycode : Utils.keycode_d ; width : keyWidth ; height : keyHeight }
 
296
            Key { id : key_f ; keycode : Utils.keycode_f ; width : keyWidth ; height : keyHeight }
 
297
            Key { id : key_g ; keycode : Utils.keycode_g ; width : keyWidth ; height : keyHeight }
 
298
            Key { id : key_h ; keycode : Utils.keycode_h ; width : keyWidth ; height : keyHeight }
 
299
            Key { id : key_j ; keycode : Utils.keycode_j ; width : keyWidth ; height : keyHeight }
 
300
            Key { id : key_k ; keycode : Utils.keycode_k ; width : keyWidth ; height : keyHeight }
 
301
            Key { id : key_l ; keycode : Utils.keycode_l ; width : keyWidth ; height : keyHeight }
 
302
            Key { id : key_enter ; keycode : Utils.keycode_enter ; width : keyWidth * 1.2 ; height : keyHeight }
 
303
        }
 
304
        Row {
 
305
            anchors.horizontalCenter : parent.horizontalCenter
 
306
            ProxyMouseArea { id : ikey_shift_l ; width : keyWidth * 0.75 ; height : keyHeight }
 
307
            Key { id : key_z ; keycode : Utils.keycode_z ; width : keyWidth ; height : keyHeight }
 
308
            Key { id : key_x ; keycode : Utils.keycode_x ; width : keyWidth ; height : keyHeight }
 
309
            Key { id : key_c ; keycode : Utils.keycode_c ; width : keyWidth ; height : keyHeight }
 
310
            Key { id : key_v ; keycode : Utils.keycode_v ; width : keyWidth ; height : keyHeight }
 
311
            Key { id : key_b ; keycode : Utils.keycode_b ; width : keyWidth ; height : keyHeight }
 
312
            Key { id : key_n ; keycode : Utils.keycode_n ; width : keyWidth ; height : keyHeight }
 
313
            Key { id : key_m ; keycode : Utils.keycode_m ; width : keyWidth ; height : keyHeight }
 
314
            Key { id : key_comma ; keycode : Utils.keycode_comma ; width : keyWidth ; height : keyHeight }
 
315
            Key { id : key_dot ; keycode : Utils.keycode_dot ; width : keyWidth ; height : keyHeight }
 
316
            ProxyMouseArea { id : ikey_shift_r ; width : keyWidth * 0.75 ; height : keyHeight }
 
317
        }
 
318
        Row {
 
319
            anchors.horizontalCenter : parent.horizontalCenter
 
320
            Key { id : key_shift_l ; keycode : Utils.keycode_shift_l ; width : keyWidth * 1.75 ; height : keyHeight }
 
321
            ProxyMouseArea { id : ikey_shift_l_2 ; width : keyWidth * 0.25 ; height : keyHeight }
 
322
            Key { id : key_alt_l ; keycode : Utils.keycode_alt_l ; width : keyWidth * 1.5 ; height : keyHeight }
 
323
            ProxyMouseArea { id : ikey_alt_l ; width : keyWidth * 0.25 ; height : keyHeight }
 
324
            Key { id : key_space ; keycode : Utils.keycode_space ; width : keyWidth * 3.0 ; height : keyHeight }
 
325
            ProxyMouseArea { id : ikey_alt_r ; width : keyWidth * 0.25 ; height : keyHeight }
 
326
            Key { id : key_alt_r ; keycode : Utils.keycode_alt_r ; width : keyWidth * 1.5 ; height : keyHeight }
 
327
            ProxyMouseArea { id : ikey_shift_r_2 ; width : keyWidth * 0.25 ; height : keyHeight }
 
328
            Key { id : key_shift_r ; keycode : Utils.keycode_shift_r ; width : keyWidth * 1.75 ; height : keyHeight }
 
329
        }
 
330
    }
 
331
    ProxyMouseArea {
 
332
        id : ikey_l ; width : keyWidth * 0.35 ; height : keyHeight
 
333
        x : key_l.x + key_l.parent.x + key_l.parent.parent.x + key_l.width
 
334
        y : key_l.y + key_l.parent.y + key_l.parent.parent.y
 
335
    }
 
336
    /*}*/
 
337
 
 
338
    Component.onCompleted : {
 
339
        ikey_a.target = key_a
 
340
        if ( useIKey_l )
 
341
            ikey_l.target = key_l
 
342
        else
 
343
            ikey_l.target = key_enter
 
344
        ikey_p.target = key_p
 
345
        ikey_shift_l.target = key_shift_l
 
346
        ikey_shift_r.target = key_shift_r
 
347
        ikey_shift_l_2.target = key_shift_l
 
348
        ikey_shift_r_2.target = key_shift_r
 
349
        ikey_alt_l.target = key_alt_l
 
350
        ikey_alt_r.target = key_alt_r
 
351
    }
 
352
}