Merge remote-tracking branch 'security/tizen'
[platform/core/csapi/tizenfx.git] / src / Tizen.NUI / src / public / ImfManager.cs
1 /** Copyright (c) 2017 Samsung Electronics Co., Ltd.
2 *
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 *
15 */
16 using System;
17 using System.Runtime.InteropServices;
18
19 namespace Tizen.NUI
20 {
21     /// <summary>
22     /// Specifically manages the ecore input method framework which enables the virtual or hardware keyboards.
23     /// </summary>
24     public class ImfManager : BaseHandle
25     {
26         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
27
28         internal ImfManager(IntPtr cPtr, bool cMemoryOwn) : base(NDalicManualPINVOKE.ImfManager_SWIGUpcast(cPtr), cMemoryOwn)
29         {
30             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
31         }
32
33         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(ImfManager obj)
34         {
35             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
36         }
37
38         protected override void Dispose(DisposeTypes type)
39         {
40             if (disposed)
41             {
42                 return;
43             }
44
45             if (type == DisposeTypes.Explicit)
46             {
47                 //Called by User
48                 //Release your own managed resources here.
49                 //You should release all of your own disposable objects here.
50
51             }
52
53             //Release your own unmanaged resources here.
54             //You should not access any managed member here except static instance.
55             //because the execution order of Finalizes is non-deterministic.
56
57             if (swigCPtr.Handle != IntPtr.Zero)
58             {
59                 if (swigCMemOwn)
60                 {
61                     swigCMemOwn = false;
62                     NDalicManualPINVOKE.delete_ImfManager(swigCPtr);
63                 }
64                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, IntPtr.Zero);
65             }
66
67             base.Dispose(type);
68         }
69
70         /// <summary>
71         /// This structure is used to pass on data from the IMF regarding predictive text.
72         /// </summary>
73         public class ImfEventData : global::System.IDisposable
74         {
75             private global::System.Runtime.InteropServices.HandleRef swigCPtr;
76             protected bool swigCMemOwn;
77
78             internal ImfEventData(IntPtr cPtr, bool cMemoryOwn)
79             {
80                 swigCMemOwn = cMemoryOwn;
81                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
82             }
83
84             internal static global::System.Runtime.InteropServices.HandleRef getCPtr(ImfEventData obj)
85             {
86                 return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
87             }
88
89             //A Flag to check who called Dispose(). (By User or DisposeQueue)
90             private bool isDisposeQueued = false;
91             //A Flat to check if it is already disposed.
92             protected bool disposed = false;
93
94
95             ~ImfEventData()
96             {
97                 if (!isDisposeQueued)
98                 {
99                     isDisposeQueued = true;
100                     DisposeQueue.Instance.Add(this);
101                 }
102             }
103
104             /// <summary>
105             /// Dispose pattern
106             /// </summary>
107             public void Dispose()
108             {
109                 //Throw excpetion if Dispose() is called in separate thread.
110                 if (!Window.IsInstalled())
111                 {
112                     throw new System.InvalidOperationException("This API called from separate thread. This API must be called from MainThread.");
113                 }
114
115                 if (isDisposeQueued)
116                 {
117                     Dispose(DisposeTypes.Implicit);
118                 }
119                 else
120                 {
121                     Dispose(DisposeTypes.Explicit);
122                     System.GC.SuppressFinalize(this);
123                 }
124             }
125
126             protected virtual void Dispose(DisposeTypes type)
127             {
128                 if (disposed)
129                 {
130                     return;
131                 }
132
133                 if (type == DisposeTypes.Explicit)
134                 {
135                     //Called by User
136                     //Release your own managed resources here.
137                     //You should release all of your own disposable objects here.
138
139                 }
140
141                 //Release your own unmanaged resources here.
142                 //You should not access any managed member here except static instance.
143                 //because the execution order of Finalizes is non-deterministic.
144
145                 if (swigCPtr.Handle != IntPtr.Zero)
146                 {
147                     if (swigCMemOwn)
148                     {
149                         swigCMemOwn = false;
150                         NDalicManualPINVOKE.delete_ImfManager_ImfEventData(swigCPtr);
151                     }
152                     swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, IntPtr.Zero);
153                 }
154
155                 disposed = true;
156             }
157
158             internal static ImfEventData GetImfEventDataFromPtr(IntPtr cPtr)
159             {
160                 ImfEventData ret = new ImfEventData(cPtr, false);
161                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
162                 return ret;
163             }
164
165             /// <summary>
166             /// Default Constructor
167             /// </summary>
168             public ImfEventData() : this(NDalicManualPINVOKE.new_ImfManager_ImfEventData__SWIG_0(), true)
169             {
170                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
171             }
172
173             /// <summary>
174             /// Constructor
175             /// </summary>
176             /// <param name="aEventName">The name of the event from the IMF.</param>
177             /// <param name="aPredictiveString">The pre-edit or commit string.</param>
178             /// <param name="aCursorOffset">Start position from the current cursor position to start deleting characters.</param>
179             /// <param name="aNumberOfChars">The number of characters to delete from the cursorOffset.</param>
180             public ImfEventData(ImfManager.ImfEvent aEventName, string aPredictiveString, int aCursorOffset, int aNumberOfChars) : this(NDalicManualPINVOKE.new_ImfManager_ImfEventData__SWIG_1((int)aEventName, aPredictiveString, aCursorOffset, aNumberOfChars), true)
181             {
182                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
183             }
184
185             /// <summary>
186             /// The pre-edit or commit string.
187             /// </summary>
188             [Obsolete("Please do not use! this will be deprecated")]
189             public string predictiveString
190             {
191                 set
192                 {
193                     NDalicManualPINVOKE.ImfManager_ImfEventData_predictiveString_set(swigCPtr, value);
194                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
195                 }
196                 get
197                 {
198                     string ret = NDalicManualPINVOKE.ImfManager_ImfEventData_predictiveString_get(swigCPtr);
199                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
200                     return ret;
201                 }
202             }
203
204             /// <summary>
205             /// The pre-edit or commit string.
206             /// </summary>
207             public string PredictiveString
208             {
209                 set
210                 {
211                     NDalicManualPINVOKE.ImfManager_ImfEventData_predictiveString_set(swigCPtr, value);
212                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
213                 }
214                 get
215                 {
216                     string ret = NDalicManualPINVOKE.ImfManager_ImfEventData_predictiveString_get(swigCPtr);
217                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
218                     return ret;
219                 }
220             }
221
222             /// <summary>
223             /// The name of the event from the IMF.
224             /// </summary>
225             [Obsolete("Please do not use! this will be deprecated")]
226             public ImfManager.ImfEvent eventName
227             {
228                 set
229                 {
230                     NDalicManualPINVOKE.ImfManager_ImfEventData_eventName_set(swigCPtr, (int)value);
231                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
232                 }
233                 get
234                 {
235                     ImfManager.ImfEvent ret = (ImfManager.ImfEvent)NDalicManualPINVOKE.ImfManager_ImfEventData_eventName_get(swigCPtr);
236                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
237                     return ret;
238                 }
239             }
240
241             /// <summary>
242             /// The name of the event from the IMF.
243             /// </summary>
244             public ImfManager.ImfEvent EventName
245             {
246                 set
247                 {
248                     NDalicManualPINVOKE.ImfManager_ImfEventData_eventName_set(swigCPtr, (int)value);
249                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
250                 }
251                 get
252                 {
253                     ImfManager.ImfEvent ret = (ImfManager.ImfEvent)NDalicManualPINVOKE.ImfManager_ImfEventData_eventName_get(swigCPtr);
254                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
255                     return ret;
256                 }
257             }
258
259             /// <summary>
260             /// Start position from the current cursor position to start deleting characters.
261             /// </summary>
262             [Obsolete("Please do not use! this will be deprecated")]
263             public int cursorOffset
264             {
265                 set
266                 {
267                     NDalicManualPINVOKE.ImfManager_ImfEventData_cursorOffset_set(swigCPtr, value);
268                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
269                 }
270                 get
271                 {
272                     int ret = NDalicManualPINVOKE.ImfManager_ImfEventData_cursorOffset_get(swigCPtr);
273                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
274                     return ret;
275                 }
276             }
277
278             /// <summary>
279             /// Start position from the current cursor position to start deleting characters.
280             /// </summary>
281             public int CursorOffset
282             {
283                 set
284                 {
285                     NDalicManualPINVOKE.ImfManager_ImfEventData_cursorOffset_set(swigCPtr, value);
286                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
287                 }
288                 get
289                 {
290                     int ret = NDalicManualPINVOKE.ImfManager_ImfEventData_cursorOffset_get(swigCPtr);
291                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
292                     return ret;
293                 }
294             }
295
296             /// <summary>
297             /// Number of characters to delete from the cursorOffset.
298             /// </summary>
299             [Obsolete("Please do not use! this will be deprecated")]
300             public int numberOfChars
301             {
302                 set
303                 {
304                     NDalicManualPINVOKE.ImfManager_ImfEventData_numberOfChars_set(swigCPtr, value);
305                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
306                 }
307                 get
308                 {
309                     int ret = NDalicManualPINVOKE.ImfManager_ImfEventData_numberOfChars_get(swigCPtr);
310                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
311                     return ret;
312                 }
313             }
314
315             /// <summary>
316             /// Number of characters to delete from the cursorOffset.
317             /// </summary>
318             public int NumberOfChars
319             {
320                 set
321                 {
322                     NDalicManualPINVOKE.ImfManager_ImfEventData_numberOfChars_set(swigCPtr, value);
323                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
324                 }
325                 get
326                 {
327                     int ret = NDalicManualPINVOKE.ImfManager_ImfEventData_numberOfChars_get(swigCPtr);
328                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
329                     return ret;
330                 }
331             }
332
333         }
334
335         /// <summary>
336         /// Data required by IMF from the callback.
337         /// </summary>
338         public class ImfCallbackData : global::System.IDisposable
339         {
340             private global::System.Runtime.InteropServices.HandleRef swigCPtr;
341             protected bool swigCMemOwn;
342
343             internal IntPtr GetImfCallbackDataPtr()
344             {
345                 return (IntPtr)swigCPtr;
346             }
347
348             internal ImfCallbackData(IntPtr cPtr, bool cMemoryOwn)
349             {
350                 swigCMemOwn = cMemoryOwn;
351                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
352             }
353
354             internal static global::System.Runtime.InteropServices.HandleRef getCPtr(ImfCallbackData obj)
355             {
356                 return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
357             }
358
359             //A Flag to check who called Dispose(). (By User or DisposeQueue)
360             private bool isDisposeQueued = false;
361             //A Flat to check if it is already disposed.
362             protected bool disposed = false;
363
364
365             ~ImfCallbackData()
366             {
367                 if (!isDisposeQueued)
368                 {
369                     isDisposeQueued = true;
370                     DisposeQueue.Instance.Add(this);
371                 }
372             }
373
374             /// <summary>
375             /// Dispose pattern
376             /// </summary>
377             public void Dispose()
378             {
379                 //Throw excpetion if Dispose() is called in separate thread.
380                 if (!Window.IsInstalled())
381                 {
382                     throw new System.InvalidOperationException("This API called from separate thread. This API must be called from MainThread.");
383                 }
384
385                 if (isDisposeQueued)
386                 {
387                     Dispose(DisposeTypes.Implicit);
388                 }
389                 else
390                 {
391                     Dispose(DisposeTypes.Explicit);
392                     System.GC.SuppressFinalize(this);
393                 }
394             }
395
396             protected virtual void Dispose(DisposeTypes type)
397             {
398                 if (disposed)
399                 {
400                     return;
401                 }
402
403                 if (type == DisposeTypes.Explicit)
404                 {
405                     //Called by User
406                     //Release your own managed resources here.
407                     //You should release all of your own disposable objects here.
408
409                 }
410
411                 //Release your own unmanaged resources here.
412                 //You should not access any managed member here except static instance.
413                 //because the execution order of Finalizes is non-deterministic.
414
415                 if (swigCPtr.Handle != IntPtr.Zero)
416                 {
417                     if (swigCMemOwn)
418                     {
419                         swigCMemOwn = false;
420                         NDalicManualPINVOKE.delete_ImfManager_ImfCallbackData(swigCPtr);
421                     }
422                     swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, IntPtr.Zero);
423                 }
424
425                 disposed = true;
426             }
427
428             internal static ImfCallbackData GetImfCallbackDataFromPtr(IntPtr cPtr)
429             {
430                 ImfCallbackData ret = new ImfCallbackData(cPtr, false);
431                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
432                 return ret;
433             }
434
435             /// <summary>
436             /// Default Constructor
437             /// </summary>
438             public ImfCallbackData() : this(NDalicManualPINVOKE.new_ImfManager_ImfCallbackData__SWIG_0(), true)
439             {
440                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
441             }
442
443             /// <summary>
444             /// Constructor
445             /// </summary>
446             /// <param name="aUpdate">True if cursor position needs to be updated.</param>
447             /// <param name="aCursorPosition">New position of cursor.</param>
448             /// <param name="aCurrentText">Current text string.</param>
449             /// <param name="aPreeditResetRequired">Flag if preedit reset is required.</param>
450             public ImfCallbackData(bool aUpdate, int aCursorPosition, string aCurrentText, bool aPreeditResetRequired) : this(NDalicManualPINVOKE.new_ImfManager_ImfCallbackData__SWIG_1(aUpdate, aCursorPosition, aCurrentText, aPreeditResetRequired), true)
451             {
452                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
453             }
454
455             /// <summary>
456             /// Current text string.
457             /// </summary>
458             [Obsolete("Please do not use! this will be deprecated")]
459             public string currentText
460             {
461                 set
462                 {
463                     NDalicManualPINVOKE.ImfManager_ImfCallbackData_currentText_set(swigCPtr, value);
464                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
465                 }
466                 get
467                 {
468                     string ret = NDalicManualPINVOKE.ImfManager_ImfCallbackData_currentText_get(swigCPtr);
469                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
470                     return ret;
471                 }
472             }
473
474             /// <summary>
475             /// Current text string.
476             /// </summary>
477             public string CurrentText
478             {
479                 set
480                 {
481                     NDalicManualPINVOKE.ImfManager_ImfCallbackData_currentText_set(swigCPtr, value);
482                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
483                 }
484                 get
485                 {
486                     string ret = NDalicManualPINVOKE.ImfManager_ImfCallbackData_currentText_get(swigCPtr);
487                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
488                     return ret;
489                 }
490             }
491
492             /// <summary>
493             /// Current text string.
494             /// </summary>
495             [Obsolete("Please do not use! this will be deprecated")]
496             public int cursorPosition
497             {
498                 set
499                 {
500                     NDalicManualPINVOKE.ImfManager_ImfCallbackData_cursorPosition_set(swigCPtr, value);
501                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
502                 }
503                 get
504                 {
505                     int ret = NDalicManualPINVOKE.ImfManager_ImfCallbackData_cursorPosition_get(swigCPtr);
506                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
507                     return ret;
508                 }
509             }
510
511             /// <summary>
512             /// Current text string.
513             /// </summary>
514             public int CursorPosition
515             {
516                 set
517                 {
518                     NDalicManualPINVOKE.ImfManager_ImfCallbackData_cursorPosition_set(swigCPtr, value);
519                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
520                 }
521                 get
522                 {
523                     int ret = NDalicManualPINVOKE.ImfManager_ImfCallbackData_cursorPosition_get(swigCPtr);
524                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
525                     return ret;
526                 }
527             }
528
529             /// <summary>
530             /// If cursor position needs to be updated.
531             /// </summary>
532             [Obsolete("Please do not use! this will be deprecated")]
533             public bool update
534             {
535                 set
536                 {
537                     NDalicManualPINVOKE.ImfManager_ImfCallbackData_update_set(swigCPtr, value);
538                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
539                 }
540                 get
541                 {
542                     bool ret = NDalicManualPINVOKE.ImfManager_ImfCallbackData_update_get(swigCPtr);
543                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
544                     return ret;
545                 }
546             }
547
548             /// <summary>
549             /// If cursor position needs to be updated.
550             /// </summary>
551             public bool Update
552             {
553                 set
554                 {
555                     NDalicManualPINVOKE.ImfManager_ImfCallbackData_update_set(swigCPtr, value);
556                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
557                 }
558                 get
559                 {
560                     bool ret = NDalicManualPINVOKE.ImfManager_ImfCallbackData_update_get(swigCPtr);
561                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
562                     return ret;
563                 }
564             }
565
566             /// <summary>
567             /// Flag if preedit reset is required.
568             /// </summary>
569             [Obsolete("Please do not use! this will be deprecated")]
570             public bool preeditResetRequired
571             {
572                 set
573                 {
574                     NDalicManualPINVOKE.ImfManager_ImfCallbackData_preeditResetRequired_set(swigCPtr, value);
575                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
576                 }
577                 get
578                 {
579                     bool ret = NDalicManualPINVOKE.ImfManager_ImfCallbackData_preeditResetRequired_get(swigCPtr);
580                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
581                     return ret;
582                 }
583             }
584
585             /// <summary>
586             /// Flag if preedit reset is required.
587             /// </summary>
588             public bool PreeditResetRequired
589             {
590                 set
591                 {
592                     NDalicManualPINVOKE.ImfManager_ImfCallbackData_preeditResetRequired_set(swigCPtr, value);
593                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
594                 }
595                 get
596                 {
597                     bool ret = NDalicManualPINVOKE.ImfManager_ImfCallbackData_preeditResetRequired_get(swigCPtr);
598                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
599                     return ret;
600                 }
601             }
602
603         }
604
605         /// <summary>
606         /// Retrieve a handle to the instance of ImfManager.
607         /// </summary>
608         /// <returns>A handle to the ImfManager.</returns>
609         public static ImfManager Get()
610         {
611             ImfManager ret = new ImfManager(NDalicManualPINVOKE.ImfManager_Get(), true);
612             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
613             return ret;
614         }
615
616         /// <summary>
617         /// Activate the IMF.<br/>
618         /// It means that the text editing is started at somewhere.<br/>
619         /// If the H/W keyboard isn't connected then it will show the virtual keyboard.
620         /// </summary>
621         public void Activate()
622         {
623             NDalicManualPINVOKE.ImfManager_Activate(swigCPtr);
624             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
625         }
626
627         /// <summary>
628         /// Deactivate the IMF.<br/>
629         /// It means that the text editing is finished at somewhere.
630         /// </summary>
631         public void Deactivate()
632         {
633             NDalicManualPINVOKE.ImfManager_Deactivate(swigCPtr);
634             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
635         }
636
637         /// <summary>
638         /// Get the restoration status, which controls if the keyboard is restored after the focus lost then regained.<br/>
639         /// If true then keyboard will be restored (activated) after focus is regained.
640         /// </summary>
641         /// <returns>Restoration status.</returns>
642         public bool RestoreAfterFocusLost()
643         {
644             bool ret = NDalicManualPINVOKE.ImfManager_RestoreAfterFocusLost(swigCPtr);
645             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
646             return ret;
647         }
648
649         /// <summary>
650         /// Set status whether the IMF has to restore the keyboard after losing focus.
651         /// </summary>
652         /// <param name="toggle">True means that keyboard should be restored after focus lost and regained.</param>
653         public void SetRestoreAfterFocusLost(bool toggle)
654         {
655             NDalicManualPINVOKE.ImfManager_SetRestoreAfterFocusLost(swigCPtr, toggle);
656             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
657         }
658
659         /// <summary>
660         /// Send message reset the pred-edit state / imf module.
661         /// </summary>
662         public new void Reset()
663         {
664             NDalicManualPINVOKE.ImfManager_Reset(swigCPtr);
665             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
666         }
667
668         /// <summary>
669         /// Notifies IMF context that the cursor position has changed, required for features like auto-capitalisation.
670         /// </summary>
671         public void NotifyCursorPosition()
672         {
673             NDalicManualPINVOKE.ImfManager_NotifyCursorPosition(swigCPtr);
674             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
675         }
676
677         /// <summary>
678         /// Sets cursor position stored in VirtualKeyboard, this is required by the IMF context.
679         /// </summary>
680         /// <param name="cursorPosition">Position of cursor.</param>
681         public void SetCursorPosition(uint cursorPosition)
682         {
683             NDalicManualPINVOKE.ImfManager_SetCursorPosition(swigCPtr, cursorPosition);
684             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
685         }
686
687         /// <summary>
688         /// Gets cursor position stored in VirtualKeyboard, this is required by the IMF context.
689         /// </summary>
690         /// <returns>Current position of cursor</returns>
691         public uint GetCursorPosition()
692         {
693             uint ret = NDalicManualPINVOKE.ImfManager_GetCursorPosition(swigCPtr);
694             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
695             return ret;
696         }
697
698         /// <summary>
699         /// Method to store the string required by the IMF, this is used to provide predictive word suggestions.
700         /// </summary>
701         /// <param name="text">The text string surrounding the current cursor point.</param>
702         public void SetSurroundingText(string text)
703         {
704             NDalicManualPINVOKE.ImfManager_SetSurroundingText(swigCPtr, text);
705             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
706         }
707
708         /// <summary>
709         /// Gets current text string set within the IMF manager, this is used to offer predictive suggestions.
710         /// </summary>
711         /// <returns>Surrounding text.</returns>
712         public string GetSurroundingText()
713         {
714             string ret = NDalicManualPINVOKE.ImfManager_GetSurroundingText(swigCPtr);
715             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
716             return ret;
717         }
718
719         /// <summary>
720         /// Notifies IMF context that text input is set to multi line or not.
721         /// </summary>
722         /// <param name="multiLine">True if multiline text input is used.</param>
723         public void NotifyTextInputMultiLine(bool multiLine)
724         {
725             NDalicManualPINVOKE.ImfManager_NotifyTextInputMultiLine(swigCPtr, multiLine);
726             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
727         }
728
729         /// <summary>
730         /// Returns text direction of the keyboard's current input language.
731         /// </summary>
732         /// <returns>The direction of the text.</returns>
733         public ImfManager.TextDirection GetTextDirection()
734         {
735             ImfManager.TextDirection ret = (ImfManager.TextDirection)NDalicManualPINVOKE.ImfManager_GetTextDirection(swigCPtr);
736             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
737             return ret;
738         }
739
740         /// <summary>
741         /// Provides size and position of keyboard.<br/>
742         /// Position is relative to whether keyboard is visible or not.<br/>
743         /// If keyboard is not visible then position will be off the screen.<br/>
744         /// If keyboard is not being shown when this method is called the keyboard is partially setup (IMFContext) to get<br/>
745         /// the values then taken down.  So ideally GetInputMethodArea() should be called after Show().
746         /// </summary>
747         /// <returns>Rectangle which is keyboard panel x, y, width, height</returns>
748         public Rectangle GetInputMethodArea()
749         {
750             Rectangle ret = new Rectangle(NDalicManualPINVOKE.ImfManager_GetInputMethodArea(swigCPtr), true);
751             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
752             return ret;
753         }
754
755         internal void ApplyOptions(InputMethodOptions options)
756         {
757             NDalicManualPINVOKE.ImfManager_ApplyOptions(swigCPtr, InputMethodOptions.getCPtr(options));
758             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
759         }
760
761         /// <summary>
762         /// Sets up the input-panel specific data.
763         /// </summary>
764         /// <param name="text">The specific data to be set to the input panel.</param>
765         public void SetInputPanelUserData(string text)
766         {
767             NDalicManualPINVOKE.ImfManager_SetInputPanelUserData(swigCPtr, text);
768             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
769         }
770
771         /// <summary>
772         /// Gets the specific data of the current active input panel.
773         /// </summary>
774         /// <param name="text">The specific data to be got from the input panel.</param>
775         public void GetInputPanelUserData(out string text)
776         {
777             NDalicManualPINVOKE.ImfManager_GetInputPanelUserData(swigCPtr, out text);
778             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
779         }
780
781         /// <summary>
782         /// Gets the state of the current active input panel.
783         /// </summary>
784         /// <returns>The state of the input panel.</returns>
785         public ImfManager.State GetInputPanelState()
786         {
787             ImfManager.State ret = (ImfManager.State)NDalicManualPINVOKE.ImfManager_GetInputPanelState(swigCPtr);
788             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
789             return ret;
790         }
791
792         /// <summary>
793         /// Sets the return key on the input panel to be visible or invisible.<br/>
794         /// The default is true.
795         /// </summary>
796         /// <param name="visible">True if the return key is visible(enabled), false otherwise.</param>
797         public void SetReturnKeyState(bool visible)
798         {
799             NDalicManualPINVOKE.ImfManager_SetReturnKeyState(swigCPtr, visible);
800             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
801         }
802
803         /// <summary>
804         /// Enable to show the input panel automatically when focused.
805         /// </summary>
806         /// <param name="enabled">If true, the input panel will be shown when focused.</param>
807         public void AutoEnableInputPanel(bool enabled)
808         {
809             NDalicManualPINVOKE.ImfManager_AutoEnableInputPanel(swigCPtr, enabled);
810             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
811         }
812
813         /// <summary>
814         /// Shows the input panel.
815         /// </summary>
816         public void ShowInputPanel()
817         {
818             NDalicManualPINVOKE.ImfManager_ShowInputPanel(swigCPtr);
819             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
820         }
821
822         /// <summary>
823         /// Hides the input panel.
824         /// </summary>
825         public void HideInputPanel()
826         {
827             NDalicManualPINVOKE.ImfManager_HideInputPanel(swigCPtr);
828             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
829         }
830
831         /// <summary>
832         /// Gets the keyboard type.<br/>
833         /// The default keyboard type is SoftwareKeyboard.
834         /// </summary>
835         /// <returns>The keyboard type</returns>
836         public ImfManager.KeyboardType GetKeyboardType()
837         {
838             ImfManager.KeyboardType ret = (ImfManager.KeyboardType)NDalicManualPINVOKE.ImfManager_GetKeyboardType(swigCPtr);
839             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
840             return ret;
841         }
842
843         /// <summary>
844         /// Gets the current language locale of the input panel.<br/>
845         /// Ex) en_US, en_GB, en_PH, fr_FR, ...
846         /// </summary>
847         /// <returns>The current language locale of the input panel.</returns>
848         public string GetInputPanelLocale()
849         {
850             string ret = NDalicManualPINVOKE.ImfManager_GetInputPanelLocale(swigCPtr);
851             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
852             return ret;
853         }
854
855         /// <summary>
856         /// Constructor
857         /// </summary>
858         public ImfManager() : this(NDalicManualPINVOKE.new_ImfManager(), true)
859         {
860             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
861         }
862
863         /// <summary>
864         /// ImfManager activated event arguments.
865         /// </summary>
866         [Obsolete("Please do not use! this will be deprecated")]
867         public class ImfManagerActivatedEventArgs : EventArgs
868         {
869             public ImfManager ImfManager
870             {
871                 get;
872                 set;
873             }
874         }
875
876         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
877         private delegate void ImfManagerActivatedEventCallbackType(global::System.IntPtr data);
878         private ImfManagerActivatedEventCallbackType _imfManagerActivatedEventCallback;
879         private event EventHandler<ImfManagerActivatedEventArgs> _imfManagerActivatedEventHandler;
880
881         /// <summary>
882         /// ImfManager activated event.
883         /// </summary>
884         [Obsolete("Please do not use! this will be deprecated")]
885         public event EventHandler<ImfManagerActivatedEventArgs> ImfManagerActivated
886         {
887             add
888             {
889                 if (_imfManagerActivatedEventHandler == null)
890                 {
891                     _imfManagerActivatedEventCallback = OnImfManagerActivated;
892                     ActivatedSignal().Connect(_imfManagerActivatedEventCallback);
893                 }
894
895                 _imfManagerActivatedEventHandler += value;
896             }
897             remove
898             {
899                 _imfManagerActivatedEventHandler -= value;
900
901                 if (_imfManagerActivatedEventHandler == null && _imfManagerActivatedEventCallback != null)
902                 {
903                     ActivatedSignal().Disconnect(_imfManagerActivatedEventCallback);
904                 }
905             }
906         }
907
908         private void OnImfManagerActivated(global::System.IntPtr data)
909         {
910             ImfManagerActivatedEventArgs e = new ImfManagerActivatedEventArgs();
911
912             if (data != null)
913             {
914                 e.ImfManager = Registry.GetManagedBaseHandleFromNativePtr(data) as ImfManager;
915             }
916
917             if (_imfManagerActivatedEventHandler != null)
918             {
919                 _imfManagerActivatedEventHandler(this, e);
920             }
921         }
922
923         /// <summary>
924         /// ImfManager activated event arguments.
925         /// </summary>
926         public class ActivatedEventArgs : EventArgs
927         {
928             public ImfManager ImfManager
929             {
930                 get;
931                 set;
932             }
933         }
934
935         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
936         private delegate void ActivatedEventCallbackType(IntPtr data);
937         private ActivatedEventCallbackType _activatedEventCallback;
938         private event EventHandler<ActivatedEventArgs> _activatedEventHandler;
939
940         /// <summary>
941         /// ImfManager activated.
942         /// </summary>
943         public event EventHandler<ActivatedEventArgs> Activated
944         {
945             add
946             {
947                 if (_activatedEventHandler == null)
948                 {
949                     _activatedEventCallback = OnActivated;
950                     ActivatedSignal().Connect(_activatedEventCallback);
951                 }
952
953                 _activatedEventHandler += value;
954             }
955             remove
956             {
957                 _activatedEventHandler -= value;
958
959                 if (_activatedEventHandler == null && _activatedEventCallback != null)
960                 {
961                     ActivatedSignal().Disconnect(_activatedEventCallback);
962                 }
963             }
964         }
965
966         private void OnActivated(IntPtr data)
967         {
968             ActivatedEventArgs e = new ActivatedEventArgs();
969
970             if (data != null)
971             {
972                 e.ImfManager = Registry.GetManagedBaseHandleFromNativePtr(data) as ImfManager;
973             }
974
975             if (_activatedEventHandler != null)
976             {
977                 _activatedEventHandler(this, e);
978             }
979         }
980
981         /// <summary>
982         /// ImfManager activated signal.
983         /// </summary>
984         [Obsolete("Please do not use! this will be internal")]
985         public ActivatedSignalType ActivatedSignal()
986         {
987             ActivatedSignalType ret = new ActivatedSignalType(NDalicManualPINVOKE.ImfManager_ActivatedSignal(swigCPtr), false);
988             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
989             return ret;
990         }
991
992         /// <summary>
993         /// ImfManager event received event arguments.
994         /// </summary>
995         [Obsolete("Please do not use! this will be deprecated")]
996         public class ImfManagerEventReceivedEventArgs : EventArgs
997         {
998             public ImfManager ImfManager
999             {
1000                 get;
1001                 set;
1002             }
1003         }
1004
1005         private delegate void ImfManagerEventReceivedEventCallbackType(global::System.IntPtr data);
1006         private ImfManagerEventReceivedEventCallbackType _imfManagerEventReceivedEventCallback;
1007         private event EventHandler<ImfManagerEventReceivedEventArgs> _imfManagerEventReceivedEventHandler;
1008
1009         /// <summary>
1010         /// ImfManager event received.
1011         /// </summary>
1012         [Obsolete("Please do not use! this will be deprecated")]
1013         public event EventHandler<ImfManagerEventReceivedEventArgs> ImfManagerEventReceived
1014         {
1015             add
1016             {
1017                 if (_imfManagerEventReceivedEventHandler == null)
1018                 {
1019                     _imfManagerEventReceivedEventCallback = OnImfManagerEventReceived;
1020                     EventReceivedSignal().Connect(_imfManagerEventReceivedEventCallback);
1021                 }
1022
1023                 _imfManagerEventReceivedEventHandler += value;
1024             }
1025             remove
1026             {
1027                 _imfManagerEventReceivedEventHandler -= value;
1028
1029                 if (_imfManagerEventReceivedEventHandler == null && _imfManagerEventReceivedEventCallback != null)
1030                 {
1031                     EventReceivedSignal().Disconnect(_imfManagerEventReceivedEventCallback);
1032                 }
1033             }
1034         }
1035
1036         private void OnImfManagerEventReceived(global::System.IntPtr data)
1037         {
1038             ImfManagerEventReceivedEventArgs e = new ImfManagerEventReceivedEventArgs();
1039
1040             if (data != null)
1041             {
1042                 e.ImfManager = Registry.GetManagedBaseHandleFromNativePtr(data) as ImfManager;
1043             }
1044
1045             if (_imfManagerEventReceivedEventHandler != null)
1046             {
1047                 _imfManagerEventReceivedEventHandler(this, e);
1048             }
1049         }
1050
1051         /// <summary>
1052         /// ImfManager event received event arguments.
1053         /// </summary>
1054         public class EventReceivedEventArgs : EventArgs
1055         {
1056             public ImfManager ImfManager
1057             {
1058                 get;
1059                 set;
1060             }
1061
1062             public ImfEventData ImfEventData
1063             {
1064                 get;
1065                 set;
1066             }
1067         }
1068
1069         private delegate IntPtr EventReceivedEventCallbackType(IntPtr imfManager, IntPtr imfEventData);
1070         private EventReceivedEventCallbackType _eventReceivedEventCallback;
1071         private event EventHandlerWithReturnType<object, EventReceivedEventArgs, ImfCallbackData> _eventReceivedEventHandler;
1072
1073         /// <summary>
1074         /// ImfManager event received.
1075         /// </summary>
1076         public event EventHandlerWithReturnType<object, EventReceivedEventArgs, ImfCallbackData> EventReceived
1077         {
1078             add
1079             {
1080                 if (_eventReceivedEventHandler == null)
1081                 {
1082                     _eventReceivedEventCallback = OnEventReceived;
1083                     EventReceivedSignal().Connect(_eventReceivedEventCallback);
1084                 }
1085
1086                 _eventReceivedEventHandler += value;
1087             }
1088             remove
1089             {
1090                 _eventReceivedEventHandler -= value;
1091
1092                 if (_eventReceivedEventHandler == null && _eventReceivedEventCallback != null)
1093                 {
1094                     EventReceivedSignal().Disconnect(_eventReceivedEventCallback);
1095                 }
1096             }
1097         }
1098
1099         private IntPtr OnEventReceived(IntPtr imfManager, IntPtr imfEventData)
1100         {
1101             ImfCallbackData imfCallbackData = null;
1102
1103             EventReceivedEventArgs e = new EventReceivedEventArgs();
1104
1105             if (imfManager != null)
1106             {
1107                 e.ImfManager = Registry.GetManagedBaseHandleFromNativePtr(imfManager) as ImfManager;
1108             }
1109             if (imfEventData != null)
1110             {
1111                 e.ImfEventData = ImfEventData.GetImfEventDataFromPtr(imfEventData);
1112             }
1113
1114             if (_eventReceivedEventHandler != null)
1115             {
1116                 imfCallbackData = _eventReceivedEventHandler(this, e);
1117             }
1118             if (imfCallbackData != null)
1119             {
1120                 return imfCallbackData.GetImfCallbackDataPtr();
1121             }
1122             else
1123             {
1124                 return new ImfCallbackData().GetImfCallbackDataPtr();
1125             }
1126         }
1127
1128         /// <summary>
1129         /// ImfManager event received signal.
1130         /// </summary>
1131         [Obsolete("Please do not use! this will be internal")]
1132         public ImfEventSignalType EventReceivedSignal()
1133         {
1134             ImfEventSignalType ret = new ImfEventSignalType(NDalicManualPINVOKE.ImfManager_EventReceivedSignal(swigCPtr), false);
1135             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1136             return ret;
1137         }
1138
1139         /// <summary>
1140         /// ImfManager status changed event arguments.
1141         /// </summary>
1142         [Obsolete("Please do not use! this will be deprecated")]
1143         public class ImfManagerStatusChangedEventArgs : EventArgs
1144         {
1145             public ImfManager ImfManager
1146             {
1147                 get;
1148                 set;
1149             }
1150         }
1151
1152         private delegate void ImfManagerStatusChangedEventCallbackType(global::System.IntPtr data);
1153         private ImfManagerStatusChangedEventCallbackType _imfManagerStatusChangedEventCallback;
1154         private event EventHandler<ImfManagerStatusChangedEventArgs> _imfManagerStatusChangedEventHandler;
1155
1156         /// <summary>
1157         /// ImfManager status changed.
1158         /// </summary>
1159         [Obsolete("Please do not use! this will be deprecated")]
1160         public event EventHandler<ImfManagerStatusChangedEventArgs> ImfManagerStatusChanged
1161         {
1162             add
1163             {
1164                 if (_imfManagerStatusChangedEventHandler == null)
1165                 {
1166                     _imfManagerStatusChangedEventCallback = OnImfManagerStatusChanged;
1167                     StatusChangedSignal().Connect(_imfManagerStatusChangedEventCallback);
1168                 }
1169
1170                 _imfManagerStatusChangedEventHandler += value;
1171             }
1172             remove
1173             {
1174                 _imfManagerStatusChangedEventHandler -= value;
1175
1176                 if (_imfManagerStatusChangedEventHandler == null && _imfManagerStatusChangedEventCallback != null)
1177                 {
1178                     StatusChangedSignal().Disconnect(_imfManagerStatusChangedEventCallback);
1179                 }
1180             }
1181         }
1182
1183         private void OnImfManagerStatusChanged(global::System.IntPtr data)
1184         {
1185             ImfManagerStatusChangedEventArgs e = new ImfManagerStatusChangedEventArgs();
1186
1187             if (data != null)
1188             {
1189                 e.ImfManager = Registry.GetManagedBaseHandleFromNativePtr(data) as ImfManager;
1190             }
1191
1192             if (_imfManagerStatusChangedEventHandler != null)
1193             {
1194                 _imfManagerStatusChangedEventHandler(this, e);
1195             }
1196         }
1197
1198         /// <summary>
1199         /// ImfManager status changed event arguments.
1200         /// </summary>
1201         public class StatusChangedEventArgs : EventArgs
1202         {
1203             public bool StatusChanged
1204             {
1205                 get;
1206                 set;
1207             }
1208         }
1209
1210         private delegate void StatusChangedEventCallbackType(bool statusChanged);
1211         private StatusChangedEventCallbackType _statusChangedEventCallback;
1212         private event EventHandler<StatusChangedEventArgs> _statusChangedEventHandler;
1213
1214         /// <summary>
1215         /// ImfManager status changed.
1216         /// </summary>
1217         public event EventHandler<StatusChangedEventArgs> StatusChanged
1218         {
1219             add
1220             {
1221                 if (_statusChangedEventHandler == null)
1222                 {
1223                     _statusChangedEventCallback = OnStatusChanged;
1224                     StatusChangedSignal().Connect(_statusChangedEventCallback);
1225                 }
1226
1227                 _statusChangedEventHandler += value;
1228             }
1229             remove
1230             {
1231                 _statusChangedEventHandler -= value;
1232
1233                 if (_statusChangedEventHandler == null && _statusChangedEventCallback != null)
1234                 {
1235                     StatusChangedSignal().Disconnect(_statusChangedEventCallback);
1236                 }
1237             }
1238         }
1239
1240         private void OnStatusChanged(bool statusChanged)
1241         {
1242             StatusChangedEventArgs e = new StatusChangedEventArgs();
1243
1244             e.StatusChanged = statusChanged;
1245
1246             if (_statusChangedEventHandler != null)
1247             {
1248                 _statusChangedEventHandler(this, e);
1249             }
1250         }
1251
1252         /// <summary>
1253         /// ImfManager status changed signal.
1254         /// </summary>
1255         [Obsolete("Please do not use! this will be internal")]
1256         public StatusSignalType StatusChangedSignal()
1257         {
1258             StatusSignalType ret = new StatusSignalType(NDalicManualPINVOKE.ImfManager_StatusChangedSignal(swigCPtr), false);
1259             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1260             return ret;
1261         }
1262
1263         /// <summary>
1264         /// ImfManager resized event arguments.
1265         /// </summary>
1266         [Obsolete("Please do not use! this will be deprecated")]
1267         public class ImfManagerResizedEventArgs : EventArgs
1268         {
1269             public ImfManager ImfManager
1270             {
1271                 get;
1272                 set;
1273             }
1274         }
1275
1276         private delegate void ImfManagerResizedEventCallbackType(IntPtr data);
1277         private ImfManagerResizedEventCallbackType _imfManagerResizedEventCallback;
1278         private event EventHandler<ImfManagerResizedEventArgs> _imfManagerResizedEventHandler;
1279
1280         /// <summary>
1281         /// ImfManager resized event.
1282         /// </summary>
1283         [Obsolete("Please do not use! this will be deprecated")]
1284         public event EventHandler<ImfManagerResizedEventArgs> ImfManagerResized
1285         {
1286             add
1287             {
1288                 if (_imfManagerResizedEventHandler == null)
1289                 {
1290                     _imfManagerResizedEventCallback = OnImfManagerResized;
1291                     ResizedSignal().Connect(_imfManagerResizedEventCallback);
1292                 }
1293
1294                 _imfManagerResizedEventHandler += value;
1295             }
1296             remove
1297             {
1298                 _imfManagerResizedEventHandler -= value;
1299
1300                 if (_imfManagerResizedEventHandler == null && _imfManagerResizedEventCallback != null)
1301                 {
1302                     ResizedSignal().Disconnect(_imfManagerResizedEventCallback);
1303                 }
1304             }
1305         }
1306
1307         private void OnImfManagerResized(IntPtr data)
1308         {
1309             ImfManagerResizedEventArgs e = new ImfManagerResizedEventArgs();
1310
1311             if (data != null)
1312             {
1313                 e.ImfManager = Registry.GetManagedBaseHandleFromNativePtr(data) as ImfManager;
1314             }
1315
1316             if (_imfManagerResizedEventHandler != null)
1317             {
1318                 _imfManagerResizedEventHandler(this, e);
1319             }
1320         }
1321
1322         private delegate void ResizedEventCallbackType();
1323         private ResizedEventCallbackType _resizedEventCallback;
1324         private event EventHandler _resizedEventHandler;
1325
1326         /// <summary>
1327         /// ImfManager resized.
1328         /// </summary>
1329         public event EventHandler Resized
1330         {
1331             add
1332             {
1333                 if (_resizedEventHandler == null)
1334                 {
1335                     _resizedEventCallback = OnResized;
1336                     ResizedSignal().Connect(_resizedEventCallback);
1337                 }
1338
1339                 _resizedEventHandler += value;
1340             }
1341             remove
1342             {
1343                 _resizedEventHandler -= value;
1344
1345                 if (_resizedEventHandler == null && _resizedEventCallback != null)
1346                 {
1347                     ResizedSignal().Disconnect(_resizedEventCallback);
1348                 }
1349             }
1350         }
1351
1352         private void OnResized()
1353         {
1354             if (_resizedEventHandler != null)
1355             {
1356                 _resizedEventHandler(this, null);
1357             }
1358         }
1359
1360         /// <summary>
1361         /// ImfManager resized signal.
1362         /// </summary>
1363         [Obsolete("Please do not use! this will be internal")]
1364         public ImfVoidSignalType ResizedSignal()
1365         {
1366             ImfVoidSignalType ret = new ImfVoidSignalType(NDalicManualPINVOKE.ImfManager_ResizedSignal(swigCPtr), false);
1367             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1368             return ret;
1369         }
1370
1371         /// <summary>
1372         /// ImfManager language changed event arguments.
1373         /// </summary>
1374         [Obsolete("Please do not use! this will be deprecated")]
1375         public class ImfManagerLanguageChangedEventArgs : EventArgs
1376         {
1377             public ImfManager ImfManager
1378             {
1379                 get;
1380                 set;
1381             }
1382         }
1383
1384         private delegate void ImfManagerLanguageChangedEventCallbackType(IntPtr data);
1385         private ImfManagerLanguageChangedEventCallbackType _imfManagerLanguageChangedEventCallback;
1386         private event EventHandler<ImfManagerLanguageChangedEventArgs> _imfManagerLanguageChangedEventHandler;
1387
1388         /// <summary>
1389         /// ImfManager language changed event.
1390         /// </summary>
1391         [Obsolete("Please do not use! this will be deprecated")]
1392         public event EventHandler<ImfManagerLanguageChangedEventArgs> ImfManagerLanguageChanged
1393         {
1394             add
1395             {
1396                 if (_imfManagerLanguageChangedEventHandler == null)
1397                 {
1398                     _imfManagerLanguageChangedEventCallback = OnImfManagerLanguageChanged;
1399                     LanguageChangedSignal().Connect(_imfManagerLanguageChangedEventCallback);
1400                 }
1401
1402                 _imfManagerLanguageChangedEventHandler += value;
1403             }
1404             remove
1405             {
1406                 _imfManagerLanguageChangedEventHandler -= value;
1407
1408                 if (_imfManagerLanguageChangedEventHandler == null && _imfManagerLanguageChangedEventCallback != null)
1409                 {
1410                     LanguageChangedSignal().Disconnect(_imfManagerLanguageChangedEventCallback);
1411                 }
1412             }
1413         }
1414
1415         private void OnImfManagerLanguageChanged(IntPtr data)
1416         {
1417             ImfManagerLanguageChangedEventArgs e = new ImfManagerLanguageChangedEventArgs();
1418
1419             if (data != null)
1420             {
1421                 e.ImfManager = Registry.GetManagedBaseHandleFromNativePtr(data) as ImfManager;
1422             }
1423
1424             if (_imfManagerLanguageChangedEventHandler != null)
1425             {
1426                 _imfManagerLanguageChangedEventHandler(this, e);
1427             }
1428         }
1429
1430         private delegate void LanguageChangedEventCallbackType();
1431         private LanguageChangedEventCallbackType _languageChangedEventCallback;
1432         private event EventHandler _languageChangedEventHandler;
1433
1434         /// <summary>
1435         /// ImfManager language changed.
1436         /// </summary>
1437         public event EventHandler LanguageChanged
1438         {
1439             add
1440             {
1441                 if (_languageChangedEventHandler == null)
1442                 {
1443                     _languageChangedEventCallback = OnLanguageChanged;
1444                     LanguageChangedSignal().Connect(_languageChangedEventCallback);
1445                 }
1446
1447                 _languageChangedEventHandler += value;
1448             }
1449             remove
1450             {
1451                 _languageChangedEventHandler -= value;
1452
1453                 if (_languageChangedEventHandler == null && _languageChangedEventCallback != null)
1454                 {
1455                     LanguageChangedSignal().Disconnect(_languageChangedEventCallback);
1456                 }
1457             }
1458         }
1459
1460         private void OnLanguageChanged()
1461         {
1462             if (_languageChangedEventHandler != null)
1463             {
1464                 _languageChangedEventHandler(this, null);
1465             }
1466         }
1467
1468         /// <summary>
1469         /// ImfManager language changed signal.
1470         /// </summary>
1471         [Obsolete("Please do not use! this will be internal")]
1472         public ImfVoidSignalType LanguageChangedSignal()
1473         {
1474             ImfVoidSignalType ret = new ImfVoidSignalType(NDalicManualPINVOKE.ImfManager_LanguageChangedSignal(swigCPtr), false);
1475             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1476             return ret;
1477         }
1478
1479         /// <summary>
1480         /// ImfManager keyboard type changed event arguments.
1481         /// </summary>
1482         public class KeyboardTypeChangedEventArgs : EventArgs
1483         {
1484             public KeyboardType KeyboardType
1485             {
1486                 get;
1487                 set;
1488             }
1489         }
1490
1491         private delegate void KeyboardTypeChangedEventCallbackType(KeyboardType type);
1492         private KeyboardTypeChangedEventCallbackType _keyboardTypeChangedEventCallback;
1493         private event EventHandler<KeyboardTypeChangedEventArgs> _keyboardTypeChangedEventHandler;
1494
1495         /// <summary>
1496         /// ImfManager keyboard type changed.
1497         /// </summary>
1498         public event EventHandler<KeyboardTypeChangedEventArgs> KeyboardTypeChanged
1499         {
1500             add
1501             {
1502                 if (_keyboardTypeChangedEventHandler == null)
1503                 {
1504                     _keyboardTypeChangedEventCallback = OnKeyboardTypeChanged;
1505                     KeyboardTypeChangedSignal().Connect(_keyboardTypeChangedEventCallback);
1506                 }
1507
1508                 _keyboardTypeChangedEventHandler += value;
1509             }
1510             remove
1511             {
1512                 _keyboardTypeChangedEventHandler -= value;
1513
1514                 if (_keyboardTypeChangedEventHandler == null && _keyboardTypeChangedEventCallback != null)
1515                 {
1516                     KeyboardTypeChangedSignal().Disconnect(_keyboardTypeChangedEventCallback);
1517                 }
1518             }
1519         }
1520
1521         private void OnKeyboardTypeChanged(KeyboardType type)
1522         {
1523             KeyboardTypeChangedEventArgs e = new KeyboardTypeChangedEventArgs();
1524
1525             e.KeyboardType = type;
1526
1527             if (_keyboardTypeChangedEventHandler != null)
1528             {
1529                 _keyboardTypeChangedEventHandler(this, e);
1530             }
1531         }
1532
1533         internal KeyboardTypeSignalType KeyboardTypeChangedSignal()
1534         {
1535             KeyboardTypeSignalType ret = new KeyboardTypeSignalType(NDalicManualPINVOKE.ImfManager_KeyboardTypeChangedSignal(swigCPtr), false);
1536             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1537             return ret;
1538         }
1539
1540         /// <summary>
1541         /// The direction of text.
1542         /// </summary>
1543         public enum TextDirection
1544         {
1545             /// <summary>
1546             /// Left to right.
1547             /// </summary>
1548             LeftToRight,
1549             /// <summary>
1550             /// Right to left.
1551             /// </summary>
1552             RightToLeft
1553         }
1554
1555         /// <summary>
1556         /// Events that are generated by the IMF.
1557         /// </summary>
1558         public enum ImfEvent
1559         {
1560             /// <summary>
1561             /// No event.
1562             /// </summary>
1563             Void,
1564             /// <summary>
1565             /// Pre-Edit changed.
1566             /// </summary>
1567             Preedit,
1568             /// <summary>
1569             /// Commit recieved.
1570             /// </summary>
1571             Commit,
1572             /// <summary>
1573             /// Event to delete a range of characters from the string.
1574             /// </summary>
1575             DeleteSurrounding,
1576             /// <summary>
1577             /// Event to query string and cursor position.
1578             /// </summary>
1579             GetSurrounding,
1580             /// <summary>
1581             /// Private command sent from the input panel.
1582             /// </summary>
1583             PrivateCommand
1584         }
1585
1586         /// <summary>
1587         /// Enumeration for state of the input panel.
1588         /// </summary>
1589         public enum State
1590         {
1591             /// <summary>
1592             /// Unknown state.
1593             /// </summary>
1594             Default = 0,
1595             /// <summary>
1596             /// Input panel is shown.
1597             /// </summary>
1598             Show,
1599             /// <summary>
1600             /// Input panel is hidden.
1601             /// </summary>
1602             Hide,
1603             /// <summary>
1604             /// Input panel in process of being shown.
1605             /// </summary>
1606             WillShow
1607         }
1608
1609         /// <summary>
1610         /// Enumeration for the type of Keyboard.
1611         /// </summary>
1612         public enum KeyboardType
1613         {
1614             /// <summary>
1615             /// Software keyboard (Virtual keyboard) is default.
1616             /// </summary>
1617             SoftwareKeyboard,
1618             /// <summary>
1619             /// Hardware keyboard.
1620             /// </summary>
1621             HardwareKeyboard
1622         }
1623     }
1624 }