src/Tizen.NUI/src/public/ImfManager.cs

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