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

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