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