/
Key.cs
executable file
·469 lines (430 loc) · 15.1 KB
/
Key.cs
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
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
/*
* Copyright(c) 2017 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
using System.ComponentModel;
namespace Tizen.NUI
{
/// <summary>
/// The key structure is used to store a key press.
/// </summary>
/// <since_tizen> 3 </since_tizen>
public class Key : global::System.IDisposable
{
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
/// <summary>
/// swigCMemOwn
/// </summary>
/// <since_tizen> 3 </since_tizen>
protected bool swigCMemOwn;
internal Key(global::System.IntPtr cPtr, bool cMemoryOwn)
{
swigCMemOwn = cMemoryOwn;
swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Key obj)
{
return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
}
//A Flag to check who called Dispose(). (By User or DisposeQueue)
private bool isDisposeQueued = false;
/// <summary>
/// A Flat to check if it is already disposed.
/// </summary>
/// <since_tizen> 3 </since_tizen>
protected bool disposed = false;
/// <summary>
/// Dispose.
/// </summary>
/// <since_tizen> 3 </since_tizen>
~Key()
{
if(!isDisposeQueued)
{
isDisposeQueued = true;
DisposeQueue.Instance.Add(this);
}
}
/// <summary>
/// Dispose.
/// </summary>
/// <since_tizen> 3 </since_tizen>
public void Dispose()
{
//Throw excpetion if Dispose() is called in separate thread.
if (!Window.IsInstalled())
{
throw new System.InvalidOperationException("This API called from separate thread. This API must be called from MainThread.");
}
if (isDisposeQueued)
{
Dispose(DisposeTypes.Implicit);
}
else
{
Dispose(DisposeTypes.Explicit);
System.GC.SuppressFinalize(this);
}
}
/// <summary>
/// Dispose.
/// </summary>
/// <param name="type">The dispose type.</param>
/// <since_tizen> 3 </since_tizen>
protected virtual void Dispose(DisposeTypes type)
{
if (disposed)
{
return;
}
if(type == DisposeTypes.Explicit)
{
//Called by User
//Release your own managed resources here.
//You should release all of your own disposable objects here.
}
//Release your own unmanaged resources here.
//You should not access any managed member here except static instance.
//because the execution order of Finalizes is non-deterministic.
if (swigCPtr.Handle != global::System.IntPtr.Zero)
{
if (swigCMemOwn)
{
swigCMemOwn = false;
NDalicPINVOKE.delete_Key(swigCPtr);
}
swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
}
disposed = true;
}
internal static Key GetKeyFromPtr(global::System.IntPtr cPtr)
{
Key ret = new Key(cPtr, false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
/// <summary>
/// Device name
/// </summary>
/// <since_tizen> 3 </since_tizen>
public string DeviceName
{
get
{
string ret = NDalicPINVOKE.GetDeviceName(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
}
/// <summary>
/// Name given to the key pressed.
/// </summary>
/// <since_tizen> 3 </since_tizen>
public string KeyPressedName
{
get
{
return keyPressedName;
}
set
{
keyPressedName = value;
}
}
/// <summary>
/// Get the logical key string. (eg. shift + 1 == "exclamation")
/// </summary>
/// <returns>The logical key symbol</returns>
/// <since_tizen> 5 </since_tizen>
/// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
[EditorBrowsable(EditorBrowsableState.Never)]
public string LogicalKey
{
get
{
return logicalKey;
}
}
/// <summary>
/// Get the actual string returned that should be used for input editors.
/// </summary>
/// <returns>The key string</returns>
/// <since_tizen> 5 </since_tizen>
/// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
[EditorBrowsable(EditorBrowsableState.Never)]
public string KeyPressed
{
get
{
return keyPressed;
}
}
/// <summary>
/// Keycode for the key pressed.
/// </summary>
/// <since_tizen> 3 </since_tizen>
public int KeyCode
{
get
{
return keyCode;
}
set
{
keyCode = value;
}
}
/// <summary>
/// Special keys like Shift, Alt, and Ctrl which modify the next key pressed.
/// </summary>
/// <since_tizen> 3 </since_tizen>
public int KeyModifier
{
get
{
return keyModifier;
}
set
{
keyModifier = value;
}
}
/// <summary>
/// The time (in ms) that the key event occurred.
/// </summary>
/// <since_tizen> 3 </since_tizen>
public uint Time
{
get
{
return time;
}
set
{
time = value;
}
}
/// <summary>
/// State of the key event.
/// </summary>
/// <since_tizen> 3 </since_tizen>
public Key.StateType State
{
get
{
return state;
}
set
{
state = value;
}
}
/// <summary>
/// Get the device class the key event originated from.
/// </summary>
/// <since_tizen> 3 </since_tizen>
public DeviceClassType DeviceClass
{
get
{
int ret = NDalicPINVOKE.GetDeviceClass(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return (DeviceClassType)ret;
}
}
/// <summary>
/// Get the device subclass the key event originated from.
/// </summary>
/// <since_tizen> 4 </since_tizen>
public DeviceSubClassType DeviceSubClass
{
get
{
int ret = NDalicPINVOKE.GetDeviceSubClass(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return (DeviceSubClassType)ret;
}
}
/// <summary>
/// The default constructor.
/// </summary>
/// <since_tizen> 3 </since_tizen>
public Key() : this(NDalicPINVOKE.new_Key__SWIG_0(), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
/// <summary>
/// The constructor.
/// </summary>
/// <param name="keyName">The name of the key pressed or command from the IMF, if later, then the following parameters will be needed.</param>
/// <param name="keyString">A string of input characters or key pressed.</param>
/// <param name="keyCode">The unique key code for the key pressed.</param>
/// <param name="keyModifier">The key modifier for special keys like Shift and Alt.</param>
/// <param name="timeStamp">The time (in ms) that the key event occurred.</param>
/// <param name="keyState">The state of the key event.</param>
internal Key(string keyName, string keyString, int keyCode, int keyModifier, uint timeStamp, Key.StateType keyState) : this(NDalicPINVOKE.new_Key__SWIG_1(keyName, keyString, keyCode, keyModifier, timeStamp, (int)keyState), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
/// <summary>
/// Checks to see if the Shift key modifier has been supplied.
/// </summary>
/// <returns>True if Shift modifier.</returns>
/// <since_tizen> 3 </since_tizen>
public bool IsShiftModifier()
{
bool ret = NDalicPINVOKE.Key_IsShiftModifier(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
/// <summary>
/// Checks to see if Ctrl (control) key modifier has been supplied.
/// </summary>
/// <returns>True if Ctrl modifier.</returns>
/// <since_tizen> 3 </since_tizen>
public bool IsCtrlModifier()
{
bool ret = NDalicPINVOKE.Key_IsCtrlModifier(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
/// <summary>
/// Checks to see if Alt key modifier has been supplied.
/// </summary>
/// <returns>True if Alt modifier.</returns>
/// <since_tizen> 3 </since_tizen>
public bool IsAltModifier()
{
bool ret = NDalicPINVOKE.Key_IsAltModifier(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
private string keyPressedName
{
set
{
NDalicPINVOKE.Key_keyPressedName_set(swigCPtr, value);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
get
{
string ret = NDalicPINVOKE.Key_keyPressedName_get(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
}
private string keyPressed
{
set
{
NDalicPINVOKE.Key_keyPressed_set(swigCPtr, value);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
get
{
string ret = NDalicPINVOKE.Key_keyPressed_get(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
}
private int keyCode
{
set
{
NDalicPINVOKE.Key_keyCode_set(swigCPtr, value);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
get
{
int ret = NDalicPINVOKE.Key_keyCode_get(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
}
private int keyModifier
{
set
{
NDalicPINVOKE.Key_keyModifier_set(swigCPtr, value);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
get
{
int ret = NDalicPINVOKE.Key_keyModifier_get(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
}
private uint time
{
set
{
NDalicPINVOKE.Key_time_set(swigCPtr, value);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
get
{
uint ret = NDalicPINVOKE.Key_time_get(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
}
private Key.StateType state
{
set
{
NDalicPINVOKE.Key_state_set(swigCPtr, (int)value);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
get
{
Key.StateType ret = (Key.StateType)NDalicPINVOKE.Key_state_get(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
}
private string logicalKey
{
get
{
string ret = NDalicPINVOKE.Key_logicalKey_get(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
}
/// <summary>
/// Enumeration for specifying the state of the key event.
/// </summary>
/// <since_tizen> 3 </since_tizen>
public enum StateType
{
/// <summary>
/// Key Down.
/// </summary>
/// <since_tizen> 3 </since_tizen>
Down,
/// <summary>
/// Key Up.
/// </summary>
/// <since_tizen> 3 </since_tizen>
Up,
/// <summary>
/// Key Last.
/// </summary>
/// <since_tizen> 3 </since_tizen>
Last
}
}
}