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