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