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