X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2FTizen.NUI%2Fsrc%2Fpublic%2FImfManager.cs;h=40b908b307ab6c1ed5c3cc77e28ed20d4526aaba;hb=4b35f3206e91da1679c600687ba9c753498db73f;hp=9304124082210d17a05f5d2661537fc67687c18a;hpb=f90226ffe7cef19e375866e649f6898b493ae27e;p=platform%2Fcore%2Fcsapi%2Ftizenfx.git

diff --git a/src/Tizen.NUI/src/public/ImfManager.cs b/src/Tizen.NUI/src/public/ImfManager.cs
index 9304124..40b908b 100755
--- a/src/Tizen.NUI/src/public/ImfManager.cs
+++ b/src/Tizen.NUI/src/public/ImfManager.cs
@@ -1,40 +1,47 @@
-/** Copyright (c) 2017 Samsung Electronics Co., Ltd.
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-* http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*
-*/
+/*
+ * Copyright(c) 2017 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
 using System;
 using System.Runtime.InteropServices;
+using System.ComponentModel;
 
 namespace Tizen.NUI
 {
     /// <summary>
-    /// Specifically manages the ecore input method framework which enables the virtual or hardware keyboards.
+    /// Specifically manages the input method framework which enables the virtual or hardware keyboards.
     /// </summary>
     public class ImfManager : BaseHandle
     {
         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
 
-        internal ImfManager(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicManualPINVOKE.ImfManager_SWIGUpcast(cPtr), cMemoryOwn)
+        internal ImfManager(IntPtr cPtr, bool cMemoryOwn) : base(NDalicManualPINVOKE.ImfManager_SWIGUpcast(cPtr), cMemoryOwn)
         {
             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
         }
 
         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(ImfManager obj)
         {
-            return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
+            return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
         }
 
+        /// <summary>
+        /// Dispose
+        /// </summary>
+        /// <param name="type">Dispose Type</param>
+        /// <since_tizen> 3 </since_tizen>
         protected override void Dispose(DisposeTypes type)
         {
             if (disposed)
@@ -54,6 +61,36 @@ namespace Tizen.NUI
             //You should not access any managed member here except static instance.
             //because the execution order of Finalizes is non-deterministic.
 
+            if (_keyboardTypeChangedEventCallback != null)
+            {
+                KeyboardTypeChangedSignal().Disconnect(_keyboardTypeChangedEventCallback);
+            }
+
+            if (_imfManagerLanguageChangedEventCallback != null)
+            {
+                LanguageChangedSignal().Disconnect(_imfManagerLanguageChangedEventCallback);
+            }
+
+            if (_imfManagerResizedEventCallback != null)
+            {
+                ResizedSignal().Disconnect(_imfManagerResizedEventCallback);
+            }
+
+            if (_imfManagerStatusChangedEventCallback != null)
+            {
+                StatusChangedSignal().Disconnect(_imfManagerStatusChangedEventCallback);
+            }
+
+            if (_imfManagerEventReceivedEventCallback != null)
+            {
+                EventReceivedSignal().Disconnect(_imfManagerEventReceivedEventCallback);
+            }
+
+            if (_imfManagerActivatedEventCallback != null)
+            {
+                ActivatedSignal().Disconnect(_imfManagerActivatedEventCallback);
+            }
+
             if (swigCPtr.Handle != global::System.IntPtr.Zero)
             {
                 if (swigCMemOwn)
@@ -61,7 +98,7 @@ namespace Tizen.NUI
                     swigCMemOwn = false;
                     NDalicManualPINVOKE.delete_ImfManager(swigCPtr);
                 }
-                swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
+                swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, IntPtr.Zero);
             }
 
             base.Dispose(type);
@@ -73,9 +110,13 @@ namespace Tizen.NUI
         public class ImfEventData : global::System.IDisposable
         {
             private global::System.Runtime.InteropServices.HandleRef swigCPtr;
+            /// <summary>
+            /// swigCMemOwn
+            /// </summary>
+            /// <since_tizen> 3 </since_tizen>
             protected bool swigCMemOwn;
 
-            internal ImfEventData(global::System.IntPtr cPtr, bool cMemoryOwn)
+            internal ImfEventData(IntPtr cPtr, bool cMemoryOwn)
             {
                 swigCMemOwn = cMemoryOwn;
                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
@@ -83,15 +124,21 @@ namespace Tizen.NUI
 
             internal static global::System.Runtime.InteropServices.HandleRef getCPtr(ImfEventData obj)
             {
-                return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
+                return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
             }
 
             //A Flag to check who called Dispose(). (By User or DisposeQueue)
             private bool isDisposeQueued = false;
-            //A Flat to check if it is already disposed.
+            /// <summary>
+            /// A Flat to check if it is already disposed.
+            /// </summary>
+            /// <since_tizen> 3 </since_tizen>
             protected bool disposed = false;
 
-
+            /// <summary>
+            /// Dispose.
+            /// </summary>
+            /// <since_tizen> 3 </since_tizen>
             ~ImfEventData()
             {
                 if (!isDisposeQueued)
@@ -102,8 +149,9 @@ namespace Tizen.NUI
             }
 
             /// <summary>
-            /// Dispose pattern
+            /// The dispose pattern.
             /// </summary>
+            /// <since_tizen> 3 </since_tizen>
             public void Dispose()
             {
                 //Throw excpetion if Dispose() is called in separate thread.
@@ -123,6 +171,10 @@ namespace Tizen.NUI
                 }
             }
 
+            /// <summary>
+            /// Dispose.
+            /// </summary>
+            /// <since_tizen> 3 </since_tizen>
             protected virtual void Dispose(DisposeTypes type)
             {
                 if (disposed)
@@ -142,20 +194,20 @@ namespace Tizen.NUI
                 //You should not access any managed member here except static instance.
                 //because the execution order of Finalizes is non-deterministic.
 
-                if (swigCPtr.Handle != global::System.IntPtr.Zero)
+                if (swigCPtr.Handle != IntPtr.Zero)
                 {
                     if (swigCMemOwn)
                     {
                         swigCMemOwn = false;
                         NDalicManualPINVOKE.delete_ImfManager_ImfEventData(swigCPtr);
                     }
-                    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
+                    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, IntPtr.Zero);
                 }
 
                 disposed = true;
             }
 
-            internal static ImfEventData GetImfEventDataFromPtr(global::System.IntPtr cPtr)
+            internal static ImfEventData GetImfEventDataFromPtr(IntPtr cPtr)
             {
                 ImfEventData ret = new ImfEventData(cPtr, false);
                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
@@ -163,28 +215,51 @@ namespace Tizen.NUI
             }
 
             /// <summary>
-            /// Default Constructor
+            /// The default constructor.
             /// </summary>
+            /// <since_tizen> 3 </since_tizen>
             public ImfEventData() : this(NDalicManualPINVOKE.new_ImfManager_ImfEventData__SWIG_0(), true)
             {
                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
             }
 
             /// <summary>
-            /// Constructor
+            /// The constructor.
             /// </summary>
             /// <param name="aEventName">The name of the event from the IMF.</param>
-            /// <param name="aPredictiveString">The pre-edit or commit string.</param>
-            /// <param name="aCursorOffset">Start position from the current cursor position to start deleting characters.</param>
+            /// <param name="aPredictiveString">The pre-edit or the commit string.</param>
+            /// <param name="aCursorOffset">Start the position from the current cursor position to start deleting characters.</param>
             /// <param name="aNumberOfChars">The number of characters to delete from the cursorOffset.</param>
+            /// <since_tizen> 3 </since_tizen>
             public ImfEventData(ImfManager.ImfEvent aEventName, string aPredictiveString, int aCursorOffset, int aNumberOfChars) : this(NDalicManualPINVOKE.new_ImfManager_ImfEventData__SWIG_1((int)aEventName, aPredictiveString, aCursorOffset, aNumberOfChars), true)
             {
                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
             }
 
             /// <summary>
-            /// The pre-edit or commit string.
+            /// The pre-edit or the commit string.
             /// </summary>
+            /// /// <since_tizen> 3 </since_tizen>
+            [EditorBrowsable(EditorBrowsableState.Never)]
+            public string predictiveString
+            {
+                set
+                {
+                    NDalicManualPINVOKE.ImfManager_ImfEventData_predictiveString_set(swigCPtr, value);
+                    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+                }
+                get
+                {
+                    string ret = NDalicManualPINVOKE.ImfManager_ImfEventData_predictiveString_get(swigCPtr);
+                    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+                    return ret;
+                }
+            }
+
+            /// <summary>
+            /// The pre-edit or the commit string.
+            /// </summary>
+            /// <since_tizen> 4 </since_tizen>
             public string PredictiveString
             {
                 set
@@ -203,6 +278,27 @@ namespace Tizen.NUI
             /// <summary>
             /// The name of the event from the IMF.
             /// </summary>
+            //Please do not use! this will be deprecated
+            [EditorBrowsable(EditorBrowsableState.Never)]
+            public ImfManager.ImfEvent eventName
+            {
+                set
+                {
+                    NDalicManualPINVOKE.ImfManager_ImfEventData_eventName_set(swigCPtr, (int)value);
+                    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+                }
+                get
+                {
+                    ImfManager.ImfEvent ret = (ImfManager.ImfEvent)NDalicManualPINVOKE.ImfManager_ImfEventData_eventName_get(swigCPtr);
+                    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+                    return ret;
+                }
+            }
+
+            /// <summary>
+            /// The name of the event from the IMF.
+            /// </summary>
+            /// <since_tizen> 4 </since_tizen>
             public ImfManager.ImfEvent EventName
             {
                 set
@@ -219,8 +315,29 @@ namespace Tizen.NUI
             }
 
             /// <summary>
-            /// Start position from the current cursor position to start deleting characters.
+            /// The start position from the current cursor position to start deleting characters.
             /// </summary>
+            //Please do not use! this will be deprecated
+            [EditorBrowsable(EditorBrowsableState.Never)]
+            public int cursorOffset
+            {
+                set
+                {
+                    NDalicManualPINVOKE.ImfManager_ImfEventData_cursorOffset_set(swigCPtr, value);
+                    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+                }
+                get
+                {
+                    int ret = NDalicManualPINVOKE.ImfManager_ImfEventData_cursorOffset_get(swigCPtr);
+                    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+                    return ret;
+                }
+            }
+
+            /// <summary>
+            /// The start position from the current cursor position to start deleting characters.
+            /// </summary>
+            /// <since_tizen> 4 </since_tizen>
             public int CursorOffset
             {
                 set
@@ -237,8 +354,29 @@ namespace Tizen.NUI
             }
 
             /// <summary>
-            /// Number of characters to delete from the cursorOffset.
+            /// The number of characters to delete from the cursorOffset.
             /// </summary>
+            //Please do not use! this will be deprecated
+            [EditorBrowsable(EditorBrowsableState.Never)]
+            public int numberOfChars
+            {
+                set
+                {
+                    NDalicManualPINVOKE.ImfManager_ImfEventData_numberOfChars_set(swigCPtr, value);
+                    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+                }
+                get
+                {
+                    int ret = NDalicManualPINVOKE.ImfManager_ImfEventData_numberOfChars_get(swigCPtr);
+                    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+                    return ret;
+                }
+            }
+
+            /// <summary>
+            /// The number of characters to delete from the cursorOffset.
+            /// </summary>
+            /// <since_tizen> 4 </since_tizen>
             public int NumberOfChars
             {
                 set
@@ -257,11 +395,15 @@ namespace Tizen.NUI
         }
 
         /// <summary>
-        /// Data required by IMF from the callback.
+        /// Data required by the IMF from the callback.
         /// </summary>
         public class ImfCallbackData : global::System.IDisposable
         {
             private global::System.Runtime.InteropServices.HandleRef swigCPtr;
+            /// <summary>
+            /// swigCMemOwn
+            /// </summary>
+            /// <since_tizen> 3 </since_tizen>
             protected bool swigCMemOwn;
 
             internal IntPtr GetImfCallbackDataPtr()
@@ -269,7 +411,7 @@ namespace Tizen.NUI
                 return (IntPtr)swigCPtr;
             }
 
-            internal ImfCallbackData(global::System.IntPtr cPtr, bool cMemoryOwn)
+            internal ImfCallbackData(IntPtr cPtr, bool cMemoryOwn)
             {
                 swigCMemOwn = cMemoryOwn;
                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
@@ -277,15 +419,22 @@ namespace Tizen.NUI
 
             internal static global::System.Runtime.InteropServices.HandleRef getCPtr(ImfCallbackData obj)
             {
-                return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
+                return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
             }
 
             //A Flag to check who called Dispose(). (By User or DisposeQueue)
             private bool isDisposeQueued = false;
-            //A Flat to check if it is already disposed.
+            /// <summary>
+            /// A Flat to check if it is already disposed.
+            /// </summary>
+            /// <since_tizen> 3 </since_tizen>
             protected bool disposed = false;
 
 
+            /// <summary>
+            /// Dispose.
+            /// </summary>
+            /// <since_tizen> 3 </since_tizen>
             ~ImfCallbackData()
             {
                 if (!isDisposeQueued)
@@ -296,8 +445,9 @@ namespace Tizen.NUI
             }
 
             /// <summary>
-            /// Dispose pattern
+            /// The dispose pattern.
             /// </summary>
+            /// <since_tizen> 3 </since_tizen>
             public void Dispose()
             {
                 //Throw excpetion if Dispose() is called in separate thread.
@@ -317,6 +467,10 @@ namespace Tizen.NUI
                 }
             }
 
+            /// <summary>
+            /// Dispose.
+            /// </summary>
+            /// <since_tizen> 3 </since_tizen>
             protected virtual void Dispose(DisposeTypes type)
             {
                 if (disposed)
@@ -336,20 +490,20 @@ namespace Tizen.NUI
                 //You should not access any managed member here except static instance.
                 //because the execution order of Finalizes is non-deterministic.
 
-                if (swigCPtr.Handle != global::System.IntPtr.Zero)
+                if (swigCPtr.Handle != IntPtr.Zero)
                 {
                     if (swigCMemOwn)
                     {
                         swigCMemOwn = false;
                         NDalicManualPINVOKE.delete_ImfManager_ImfCallbackData(swigCPtr);
                     }
-                    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
+                    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, IntPtr.Zero);
                 }
 
                 disposed = true;
             }
 
-            internal static ImfCallbackData GetImfCallbackDataFromPtr(global::System.IntPtr cPtr)
+            internal static ImfCallbackData GetImfCallbackDataFromPtr(IntPtr cPtr)
             {
                 ImfCallbackData ret = new ImfCallbackData(cPtr, false);
                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
@@ -357,28 +511,51 @@ namespace Tizen.NUI
             }
 
             /// <summary>
-            /// Default Constructor
+            /// The default constructor.
             /// </summary>
+            /// <since_tizen> 3 </since_tizen>
             public ImfCallbackData() : this(NDalicManualPINVOKE.new_ImfManager_ImfCallbackData__SWIG_0(), true)
             {
                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
             }
 
             /// <summary>
-            /// Constructor
+            /// The constructor.
             /// </summary>
-            /// <param name="aUpdate">True if cursor position needs to be updated.</param>
-            /// <param name="aCursorPosition">New position of cursor.</param>
-            /// <param name="aCurrentText">Current text string.</param>
+            /// <param name="aUpdate">True if the cursor position needs to be updated.</param>
+            /// <param name="aCursorPosition">The new position of the cursor.</param>
+            /// <param name="aCurrentText">The current text string.</param>
             /// <param name="aPreeditResetRequired">Flag if preedit reset is required.</param>
+            /// <since_tizen> 3 </since_tizen>
             public ImfCallbackData(bool aUpdate, int aCursorPosition, string aCurrentText, bool aPreeditResetRequired) : this(NDalicManualPINVOKE.new_ImfManager_ImfCallbackData__SWIG_1(aUpdate, aCursorPosition, aCurrentText, aPreeditResetRequired), true)
             {
                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
             }
 
             /// <summary>
-            /// Current text string.
+            /// The current text string.
             /// </summary>
+            //Please do not use! this will be deprecated
+            [EditorBrowsable(EditorBrowsableState.Never)]
+            public string currentText
+            {
+                set
+                {
+                    NDalicManualPINVOKE.ImfManager_ImfCallbackData_currentText_set(swigCPtr, value);
+                    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+                }
+                get
+                {
+                    string ret = NDalicManualPINVOKE.ImfManager_ImfCallbackData_currentText_get(swigCPtr);
+                    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+                    return ret;
+                }
+            }
+
+            /// <summary>
+            /// The current text string.
+            /// </summary>
+            /// <since_tizen> 4 </since_tizen>
             public string CurrentText
             {
                 set
@@ -395,8 +572,29 @@ namespace Tizen.NUI
             }
 
             /// <summary>
-            /// Current text string.
+            /// The current text string.
             /// </summary>
+            //Please do not use! this will be deprecated
+            [EditorBrowsable(EditorBrowsableState.Never)]
+            public int cursorPosition
+            {
+                set
+                {
+                    NDalicManualPINVOKE.ImfManager_ImfCallbackData_cursorPosition_set(swigCPtr, value);
+                    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+                }
+                get
+                {
+                    int ret = NDalicManualPINVOKE.ImfManager_ImfCallbackData_cursorPosition_get(swigCPtr);
+                    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+                    return ret;
+                }
+            }
+
+            /// <summary>
+            /// The current text string.
+            /// </summary>
+            /// <since_tizen> 4 </since_tizen>
             public int CursorPosition
             {
                 set
@@ -413,8 +611,29 @@ namespace Tizen.NUI
             }
 
             /// <summary>
-            /// If cursor position needs to be updated.
+            /// If the cursor position needs to be updated.
             /// </summary>
+            //Please do not use! this will be deprecated
+            [EditorBrowsable(EditorBrowsableState.Never)]
+            public bool update
+            {
+                set
+                {
+                    NDalicManualPINVOKE.ImfManager_ImfCallbackData_update_set(swigCPtr, value);
+                    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+                }
+                get
+                {
+                    bool ret = NDalicManualPINVOKE.ImfManager_ImfCallbackData_update_get(swigCPtr);
+                    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+                    return ret;
+                }
+            }
+
+            /// <summary>
+            /// If the cursor position needs to be updated.
+            /// </summary>
+            /// <since_tizen> 4 </since_tizen>
             public bool Update
             {
                 set
@@ -431,8 +650,29 @@ namespace Tizen.NUI
             }
 
             /// <summary>
-            /// Flag if preedit reset is required.
+            /// Flags if preedit reset is required.
+            /// </summary>
+            //Please do not use! this will be deprecated
+            [EditorBrowsable(EditorBrowsableState.Never)]
+            public bool preeditResetRequired
+            {
+                set
+                {
+                    NDalicManualPINVOKE.ImfManager_ImfCallbackData_preeditResetRequired_set(swigCPtr, value);
+                    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+                }
+                get
+                {
+                    bool ret = NDalicManualPINVOKE.ImfManager_ImfCallbackData_preeditResetRequired_get(swigCPtr);
+                    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+                    return ret;
+                }
+            }
+
+            /// <summary>
+            /// Flags if preedit reset is required.
             /// </summary>
+            /// <since_tizen> 4 </since_tizen>
             public bool PreeditResetRequired
             {
                 set
@@ -451,9 +691,19 @@ namespace Tizen.NUI
         }
 
         /// <summary>
-        /// Retrieve a handle to the instance of ImfManager.
+        /// Finalize the IMF.<br/>
+        /// </summary>
+        public void Finalize()
+        {
+            NDalicManualPINVOKE.ImfManager_Finalize(swigCPtr);
+            if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+        }
+
+        /// <summary>
+        /// Retrieves a handle to the instance of the ImfManager.
         /// </summary>
         /// <returns>A handle to the ImfManager.</returns>
+        /// <since_tizen> 3 </since_tizen>
         public static ImfManager Get()
         {
             ImfManager ret = new ImfManager(NDalicManualPINVOKE.ImfManager_Get(), true);
@@ -462,10 +712,11 @@ namespace Tizen.NUI
         }
 
         /// <summary>
-        /// Activate the IMF.<br/>
-        /// It means that the text editing is started at somewhere.<br/>
-        /// If the H/W keyboard isn't connected then it will show the virtual keyboard.
+        /// Activates the IMF.<br/>
+        /// It means that the text editing is started somewhere.<br/>
+        /// If the hardware keyboard isn't connected, then it will show the virtual keyboard.
         /// </summary>
+        /// <since_tizen> 3 </since_tizen>
         public void Activate()
         {
             NDalicManualPINVOKE.ImfManager_Activate(swigCPtr);
@@ -473,9 +724,10 @@ namespace Tizen.NUI
         }
 
         /// <summary>
-        /// Deactivate the IMF.<br/>
-        /// It means that the text editing is finished at somewhere.
+        /// Deactivates the IMF.<br/>
+        /// It means that the text editing is finished somewhere.
         /// </summary>
+        /// <since_tizen> 3 </since_tizen>
         public void Deactivate()
         {
             NDalicManualPINVOKE.ImfManager_Deactivate(swigCPtr);
@@ -483,10 +735,11 @@ namespace Tizen.NUI
         }
 
         /// <summary>
-        /// Get the restoration status, which controls if the keyboard is restored after the focus lost then regained.<br/>
-        /// If true then keyboard will be restored (activated) after focus is regained.
+        /// Gets the restoration status which controls if the keyboard is restored after the focus is lost and then regained.<br/>
+        /// If true, then the keyboard will be restored (activated) after focus is regained.
         /// </summary>
-        /// <returns>Restoration status.</returns>
+        /// <returns>The restoration status.</returns>
+        /// <since_tizen> 3 </since_tizen>
         public bool RestoreAfterFocusLost()
         {
             bool ret = NDalicManualPINVOKE.ImfManager_RestoreAfterFocusLost(swigCPtr);
@@ -495,9 +748,10 @@ namespace Tizen.NUI
         }
 
         /// <summary>
-        /// Set status whether the IMF has to restore the keyboard after losing focus.
+        /// Sets the status whether the IMF has to restore the keyboard after losing focus.
         /// </summary>
-        /// <param name="toggle">True means that keyboard should be restored after focus lost and regained.</param>
+        /// <param name="toggle">True means that keyboard should be restored after the focus is lost and regained.</param>
+        /// <since_tizen> 3 </since_tizen>
         public void SetRestoreAfterFocusLost(bool toggle)
         {
             NDalicManualPINVOKE.ImfManager_SetRestoreAfterFocusLost(swigCPtr, toggle);
@@ -505,8 +759,9 @@ namespace Tizen.NUI
         }
 
         /// <summary>
-        /// Send message reset the pred-edit state / imf module.
+        /// Sends a message reset to the preedit state or the IMF module.
         /// </summary>
+        /// <since_tizen> 3 </since_tizen>
         public new void Reset()
         {
             NDalicManualPINVOKE.ImfManager_Reset(swigCPtr);
@@ -514,8 +769,9 @@ namespace Tizen.NUI
         }
 
         /// <summary>
-        /// Notifies IMF context that the cursor position has changed, required for features like auto-capitalisation.
+        /// Notifies the IMF context that the cursor position has changed, required for features like auto-capitalization.
         /// </summary>
+        /// <since_tizen> 3 </since_tizen>
         public void NotifyCursorPosition()
         {
             NDalicManualPINVOKE.ImfManager_NotifyCursorPosition(swigCPtr);
@@ -523,9 +779,10 @@ namespace Tizen.NUI
         }
 
         /// <summary>
-        /// Sets cursor position stored in VirtualKeyboard, this is required by the IMF context.
+        /// Sets the cursor position stored in VirtualKeyboard, this is required by the IMF context.
         /// </summary>
-        /// <param name="cursorPosition">Position of cursor.</param>
+        /// <param name="cursorPosition">The position of the cursor.</param>
+        /// <since_tizen> 3 </since_tizen>
         public void SetCursorPosition(uint cursorPosition)
         {
             NDalicManualPINVOKE.ImfManager_SetCursorPosition(swigCPtr, cursorPosition);
@@ -533,9 +790,10 @@ namespace Tizen.NUI
         }
 
         /// <summary>
-        /// Gets cursor position stored in VirtualKeyboard, this is required by the IMF context.
+        /// Gets the cursor position stored in VirtualKeyboard, this is required by the IMF context.
         /// </summary>
-        /// <returns>Current position of cursor</returns>
+        /// <returns>The current position of the cursor.</returns>
+        /// <since_tizen> 3 </since_tizen>
         public uint GetCursorPosition()
         {
             uint ret = NDalicManualPINVOKE.ImfManager_GetCursorPosition(swigCPtr);
@@ -544,9 +802,10 @@ namespace Tizen.NUI
         }
 
         /// <summary>
-        /// Method to store the string required by the IMF, this is used to provide predictive word suggestions.
+        /// A method to store the string required by the IMF, this is used to provide predictive word suggestions.
         /// </summary>
         /// <param name="text">The text string surrounding the current cursor point.</param>
+        /// <since_tizen> 3 </since_tizen>
         public void SetSurroundingText(string text)
         {
             NDalicManualPINVOKE.ImfManager_SetSurroundingText(swigCPtr, text);
@@ -554,9 +813,10 @@ namespace Tizen.NUI
         }
 
         /// <summary>
-        /// Gets current text string set within the IMF manager, this is used to offer predictive suggestions.
+        /// Gets the current text string set within the IMF manager, this is used to offer predictive suggestions.
         /// </summary>
-        /// <returns>Surrounding text.</returns>
+        /// <returns>The surrounding text.</returns>
+        /// <since_tizen> 3 </since_tizen>
         public string GetSurroundingText()
         {
             string ret = NDalicManualPINVOKE.ImfManager_GetSurroundingText(swigCPtr);
@@ -565,9 +825,10 @@ namespace Tizen.NUI
         }
 
         /// <summary>
-        /// Notifies IMF context that text input is set to multi line or not.
+        /// Notifies the IMF context that text input is set to multiline or not.
         /// </summary>
         /// <param name="multiLine">True if multiline text input is used.</param>
+        /// <since_tizen> 3 </since_tizen>
         public void NotifyTextInputMultiLine(bool multiLine)
         {
             NDalicManualPINVOKE.ImfManager_NotifyTextInputMultiLine(swigCPtr, multiLine);
@@ -575,9 +836,10 @@ namespace Tizen.NUI
         }
 
         /// <summary>
-        /// Returns text direction of the keyboard's current input language.
+        /// Returns the text direction of the keyboard's current input language.
         /// </summary>
         /// <returns>The direction of the text.</returns>
+        /// <since_tizen> 3 </since_tizen>
         public ImfManager.TextDirection GetTextDirection()
         {
             ImfManager.TextDirection ret = (ImfManager.TextDirection)NDalicManualPINVOKE.ImfManager_GetTextDirection(swigCPtr);
@@ -586,13 +848,14 @@ namespace Tizen.NUI
         }
 
         /// <summary>
-        /// Provides size and position of keyboard.<br/>
-        /// Position is relative to whether keyboard is visible or not.<br/>
-        /// If keyboard is not visible then position will be off the screen.<br/>
-        /// If keyboard is not being shown when this method is called the keyboard is partially setup (IMFContext) to get<br/>
-        /// the values then taken down.  So ideally GetInputMethodArea() should be called after Show().
+        /// Provides the size and the position of the keyboard.<br/>
+        /// The position is relative to whether the keyboard is visible or not.<br/>
+        /// If the keyboard is not visible, then the position will be off the screen.<br/>
+        /// If the keyboard is not being shown when this method is called, the keyboard is partially setup (IMFContext) to get/>
+        /// the values then taken down. So ideally, GetInputMethodArea() should be called after Show().
         /// </summary>
-        /// <returns>Rectangle which is keyboard panel x, y, width, height</returns>
+        /// <returns>Rectangle which is keyboard panel x, y, width, height.</returns>
+        /// <since_tizen> 3 </since_tizen>
         public Rectangle GetInputMethodArea()
         {
             Rectangle ret = new Rectangle(NDalicManualPINVOKE.ImfManager_GetInputMethodArea(swigCPtr), true);
@@ -610,6 +873,7 @@ namespace Tizen.NUI
         /// Sets up the input-panel specific data.
         /// </summary>
         /// <param name="text">The specific data to be set to the input panel.</param>
+        /// <since_tizen> 3 </since_tizen>
         public void SetInputPanelUserData(string text)
         {
             NDalicManualPINVOKE.ImfManager_SetInputPanelUserData(swigCPtr, text);
@@ -619,7 +883,8 @@ namespace Tizen.NUI
         /// <summary>
         /// Gets the specific data of the current active input panel.
         /// </summary>
-        /// <param name="text">The specific data to be got from the input panel.</param>
+        /// <param name="text">The specific data to be received from the input panel.</param>
+        /// <since_tizen> 3 </since_tizen>
         public void GetInputPanelUserData(out string text)
         {
             NDalicManualPINVOKE.ImfManager_GetInputPanelUserData(swigCPtr, out text);
@@ -630,6 +895,7 @@ namespace Tizen.NUI
         /// Gets the state of the current active input panel.
         /// </summary>
         /// <returns>The state of the input panel.</returns>
+        /// <since_tizen> 3 </since_tizen>
         public ImfManager.State GetInputPanelState()
         {
             ImfManager.State ret = (ImfManager.State)NDalicManualPINVOKE.ImfManager_GetInputPanelState(swigCPtr);
@@ -641,7 +907,8 @@ namespace Tizen.NUI
         /// Sets the return key on the input panel to be visible or invisible.<br/>
         /// The default is true.
         /// </summary>
-        /// <param name="visible">True if the return key is visible(enabled), false otherwise.</param>
+        /// <param name="visible">True if the return key is visible (enabled), false otherwise.</param>
+        /// <since_tizen> 3 </since_tizen>
         public void SetReturnKeyState(bool visible)
         {
             NDalicManualPINVOKE.ImfManager_SetReturnKeyState(swigCPtr, visible);
@@ -649,9 +916,10 @@ namespace Tizen.NUI
         }
 
         /// <summary>
-        /// Enable to show the input panel automatically when focused.
+        /// Enables to show the input panel automatically when focused.
         /// </summary>
         /// <param name="enabled">If true, the input panel will be shown when focused.</param>
+        /// <since_tizen> 3 </since_tizen>
         public void AutoEnableInputPanel(bool enabled)
         {
             NDalicManualPINVOKE.ImfManager_AutoEnableInputPanel(swigCPtr, enabled);
@@ -661,6 +929,7 @@ namespace Tizen.NUI
         /// <summary>
         /// Shows the input panel.
         /// </summary>
+        /// <since_tizen> 3 </since_tizen>
         public void ShowInputPanel()
         {
             NDalicManualPINVOKE.ImfManager_ShowInputPanel(swigCPtr);
@@ -670,6 +939,7 @@ namespace Tizen.NUI
         /// <summary>
         /// Hides the input panel.
         /// </summary>
+        /// <since_tizen> 3 </since_tizen>
         public void HideInputPanel()
         {
             NDalicManualPINVOKE.ImfManager_HideInputPanel(swigCPtr);
@@ -680,7 +950,8 @@ namespace Tizen.NUI
         /// Gets the keyboard type.<br/>
         /// The default keyboard type is SoftwareKeyboard.
         /// </summary>
-        /// <returns>The keyboard type</returns>
+        /// <returns>The keyboard type.</returns>
+        /// <since_tizen> 4 </since_tizen>
         public ImfManager.KeyboardType GetKeyboardType()
         {
             ImfManager.KeyboardType ret = (ImfManager.KeyboardType)NDalicManualPINVOKE.ImfManager_GetKeyboardType(swigCPtr);
@@ -690,9 +961,10 @@ namespace Tizen.NUI
 
         /// <summary>
         /// Gets the current language locale of the input panel.<br/>
-        /// Ex) en_US, en_GB, en_PH, fr_FR, ...
+        /// For example, en_US, en_GB, en_PH, fr_FR, ...
         /// </summary>
         /// <returns>The current language locale of the input panel.</returns>
+        /// <since_tizen> 4 </since_tizen>
         public string GetInputPanelLocale()
         {
             string ret = NDalicManualPINVOKE.ImfManager_GetInputPanelLocale(swigCPtr);
@@ -701,25 +973,25 @@ namespace Tizen.NUI
         }
 
         /// <summary>
-        /// Constructor
+        /// The constructor.
         /// </summary>
+        /// <since_tizen> 3 </since_tizen>
         public ImfManager() : this(NDalicManualPINVOKE.new_ImfManager(), true)
         {
             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
         }
 
-        internal static ImfManager GetImfManagerFromPtr(global::System.IntPtr cPtr)
-        {
-            ImfManager ret = new ImfManager(cPtr, false);
-            if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
-            return ret;
-        }
-
         /// <summary>
         /// ImfManager activated event arguments.
         /// </summary>
+        //Please do not use! this will be deprecated
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public class ImfManagerActivatedEventArgs : EventArgs
         {
+            /// <summary>
+            /// ImfManager
+            /// </summary>
+            /// <since_tizen> 3 </since_tizen>
             public ImfManager ImfManager
             {
                 get;
@@ -730,12 +1002,13 @@ namespace Tizen.NUI
         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
         private delegate void ImfManagerActivatedEventCallbackType(global::System.IntPtr data);
         private ImfManagerActivatedEventCallbackType _imfManagerActivatedEventCallback;
-
         private event EventHandler<ImfManagerActivatedEventArgs> _imfManagerActivatedEventHandler;
 
         /// <summary>
-        /// ImfManager activated.
+        /// ImfManager activated event.
         /// </summary>
+        //Please do not use! this will be deprecated
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public event EventHandler<ImfManagerActivatedEventArgs> ImfManagerActivated
         {
             add
@@ -763,7 +1036,10 @@ namespace Tizen.NUI
         {
             ImfManagerActivatedEventArgs e = new ImfManagerActivatedEventArgs();
 
-            e.ImfManager = ImfManager.GetImfManagerFromPtr(data);
+            if (data != null)
+            {
+                e.ImfManager = Registry.GetManagedBaseHandleFromNativePtr(data) as ImfManager;
+            }
 
             if (_imfManagerActivatedEventHandler != null)
             {
@@ -771,7 +1047,75 @@ namespace Tizen.NUI
             }
         }
 
-        internal ActivatedSignalType ActivatedSignal()
+        /// <summary>
+        /// ImfManager activated event arguments.
+        /// </summary>
+        public class ActivatedEventArgs : EventArgs
+        {
+            /// <summary>
+            /// ImfManager
+            /// </summary>
+            /// <since_tizen> 3 </since_tizen>
+            public ImfManager ImfManager
+            {
+                get;
+                set;
+            }
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+        private delegate void ActivatedEventCallbackType(IntPtr data);
+        private ActivatedEventCallbackType _activatedEventCallback;
+        private event EventHandler<ActivatedEventArgs> _activatedEventHandler;
+
+        /// <summary>
+        /// ImfManager activated.
+        /// </summary>
+        /// <since_tizen> 4 </since_tizen>
+        public event EventHandler<ActivatedEventArgs> Activated
+        {
+            add
+            {
+                if (_activatedEventHandler == null)
+                {
+                    _activatedEventCallback = OnActivated;
+                    ActivatedSignal().Connect(_activatedEventCallback);
+                }
+
+                _activatedEventHandler += value;
+            }
+            remove
+            {
+                _activatedEventHandler -= value;
+
+                if (_activatedEventHandler == null && _activatedEventCallback != null)
+                {
+                    ActivatedSignal().Disconnect(_activatedEventCallback);
+                }
+            }
+        }
+
+        private void OnActivated(IntPtr data)
+        {
+            ActivatedEventArgs e = new ActivatedEventArgs();
+
+            if (data != null)
+            {
+                e.ImfManager = Registry.GetManagedBaseHandleFromNativePtr(data) as ImfManager;
+            }
+
+            if (_activatedEventHandler != null)
+            {
+                _activatedEventHandler(this, e);
+            }
+        }
+
+        /// <summary>
+        /// ImfManager activated signal.
+        /// </summary>
+        //Please do not use! this will be internal
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public ActivatedSignalType ActivatedSignal()
         {
             ActivatedSignalType ret = new ActivatedSignalType(NDalicManualPINVOKE.ImfManager_ActivatedSignal(swigCPtr), false);
             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
@@ -781,29 +1125,31 @@ namespace Tizen.NUI
         /// <summary>
         /// ImfManager event received event arguments.
         /// </summary>
+        //Please do not use! this will be deprecated
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public class ImfManagerEventReceivedEventArgs : EventArgs
         {
+            /// <summary>
+            /// ImfManager
+            /// </summary>
+            /// <since_tizen> 3 </since_tizen>
             public ImfManager ImfManager
             {
                 get;
                 set;
             }
-
-            public ImfEventData ImfEventData
-            {
-                get;
-                set;
-            }
         }
 
-        private delegate global::System.IntPtr ImfManagerEventReceivedEventCallbackType(global::System.IntPtr imfManager, global::System.IntPtr imfEventData);
+        private delegate void ImfManagerEventReceivedEventCallbackType(global::System.IntPtr data);
         private ImfManagerEventReceivedEventCallbackType _imfManagerEventReceivedEventCallback;
+        private event EventHandler<ImfManagerEventReceivedEventArgs> _imfManagerEventReceivedEventHandler;
 
-        private event EventHandlerWithReturnType<object, ImfManagerEventReceivedEventArgs, ImfCallbackData> _imfManagerEventReceivedEventHandler;
         /// <summary>
         /// ImfManager event received.
         /// </summary>
-        public event EventHandlerWithReturnType<object, ImfManagerEventReceivedEventArgs, ImfCallbackData> ImfManagerEventReceived
+        //Please do not use! this will be deprecated
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public event EventHandler<ImfManagerEventReceivedEventArgs> ImfManagerEventReceived
         {
             add
             {
@@ -826,18 +1172,96 @@ namespace Tizen.NUI
             }
         }
 
-        private global::System.IntPtr OnImfManagerEventReceived(global::System.IntPtr imfManager, global::System.IntPtr imfEventData)
+        private void OnImfManagerEventReceived(global::System.IntPtr data)
         {
-            ImfCallbackData imfCallbackData = null;
-
             ImfManagerEventReceivedEventArgs e = new ImfManagerEventReceivedEventArgs();
 
-            e.ImfManager = ImfManager.GetImfManagerFromPtr(imfManager);
-            e.ImfEventData = ImfEventData.GetImfEventDataFromPtr(imfEventData);
+            if (data != null)
+            {
+                e.ImfManager = Registry.GetManagedBaseHandleFromNativePtr(data) as ImfManager;
+            }
 
             if (_imfManagerEventReceivedEventHandler != null)
             {
-                imfCallbackData = _imfManagerEventReceivedEventHandler(this, e);
+                _imfManagerEventReceivedEventHandler(this, e);
+            }
+        }
+
+        /// <summary>
+        /// ImfManager event received event arguments.
+        /// </summary>
+        public class EventReceivedEventArgs : EventArgs
+        {
+            /// <summary>
+            /// ImfManager
+            /// </summary>
+            /// <since_tizen> 3 </since_tizen>
+            public ImfManager ImfManager
+            {
+                get;
+                set;
+            }
+
+            /// <summary>
+            /// ImfEventData
+            /// </summary>
+            /// <since_tizen> 3 </since_tizen>
+            public ImfEventData ImfEventData
+            {
+                get;
+                set;
+            }
+        }
+
+        private delegate IntPtr EventReceivedEventCallbackType(IntPtr imfManager, IntPtr imfEventData);
+        private EventReceivedEventCallbackType _eventReceivedEventCallback;
+        private event EventHandlerWithReturnType<object, EventReceivedEventArgs, ImfCallbackData> _eventReceivedEventHandler;
+
+        /// <summary>
+        /// ImfManager event received.
+        /// </summary>
+        /// <since_tizen> 4 </since_tizen>
+        public event EventHandlerWithReturnType<object, EventReceivedEventArgs, ImfCallbackData> EventReceived
+        {
+            add
+            {
+                if (_eventReceivedEventHandler == null)
+                {
+                    _eventReceivedEventCallback = OnEventReceived;
+                    EventReceivedSignal().Connect(_eventReceivedEventCallback);
+                }
+
+                _eventReceivedEventHandler += value;
+            }
+            remove
+            {
+                _eventReceivedEventHandler -= value;
+
+                if (_eventReceivedEventHandler == null && _eventReceivedEventCallback != null)
+                {
+                    EventReceivedSignal().Disconnect(_eventReceivedEventCallback);
+                }
+            }
+        }
+
+        private IntPtr OnEventReceived(IntPtr imfManager, IntPtr imfEventData)
+        {
+            ImfCallbackData imfCallbackData = null;
+
+            EventReceivedEventArgs e = new EventReceivedEventArgs();
+
+            if (imfManager != null)
+            {
+                e.ImfManager = Registry.GetManagedBaseHandleFromNativePtr(imfManager) as ImfManager;
+            }
+            if (imfEventData != null)
+            {
+                e.ImfEventData = ImfEventData.GetImfEventDataFromPtr(imfEventData);
+            }
+
+            if (_eventReceivedEventHandler != null)
+            {
+                imfCallbackData = _eventReceivedEventHandler(this, e);
             }
             if (imfCallbackData != null)
             {
@@ -849,7 +1273,12 @@ namespace Tizen.NUI
             }
         }
 
-        internal ImfEventSignalType EventReceivedSignal()
+        /// <summary>
+        /// ImfManager event received signal.
+        /// </summary>
+	    //Please do not use! this will be internal
+	   [EditorBrowsable(EditorBrowsableState.Never)]
+        public ImfEventSignalType EventReceivedSignal()
         {
             ImfEventSignalType ret = new ImfEventSignalType(NDalicManualPINVOKE.ImfManager_EventReceivedSignal(swigCPtr), false);
             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
@@ -859,22 +1288,30 @@ namespace Tizen.NUI
         /// <summary>
         /// ImfManager status changed event arguments.
         /// </summary>
+        //Please do not use! this will be deprecated
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public class ImfManagerStatusChangedEventArgs : EventArgs
         {
-            public bool StatusChanged
+            /// <summary>
+            /// ImfManager
+            /// </summary>
+            /// <since_tizen> 3 </since_tizen>
+            public ImfManager ImfManager
             {
                 get;
                 set;
             }
         }
 
-        private delegate void ImfManagerStatusChangedEventCallbackType(bool statusChanged);
+        private delegate void ImfManagerStatusChangedEventCallbackType(global::System.IntPtr data);
         private ImfManagerStatusChangedEventCallbackType _imfManagerStatusChangedEventCallback;
-
         private event EventHandler<ImfManagerStatusChangedEventArgs> _imfManagerStatusChangedEventHandler;
+
         /// <summary>
         /// ImfManager status changed.
         /// </summary>
+        //Please do not use! this will be deprecated
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public event EventHandler<ImfManagerStatusChangedEventArgs> ImfManagerStatusChanged
         {
             add
@@ -898,11 +1335,14 @@ namespace Tizen.NUI
             }
         }
 
-        private void OnImfManagerStatusChanged(bool statusChanged)
+        private void OnImfManagerStatusChanged(global::System.IntPtr data)
         {
             ImfManagerStatusChangedEventArgs e = new ImfManagerStatusChangedEventArgs();
 
-            e.StatusChanged = statusChanged;
+            if (data != null)
+            {
+                e.ImfManager = Registry.GetManagedBaseHandleFromNativePtr(data) as ImfManager;
+            }
 
             if (_imfManagerStatusChangedEventHandler != null)
             {
@@ -910,21 +1350,105 @@ namespace Tizen.NUI
             }
         }
 
-        internal StatusSignalType StatusChangedSignal()
+        /// <summary>
+        /// ImfManager status changed event arguments.
+        /// </summary>
+        public class StatusChangedEventArgs : EventArgs
+        {
+            /// <summary>
+            /// ImfManager status
+            /// </summary>
+            /// <since_tizen> 3 </since_tizen>
+            public bool StatusChanged
+            {
+                get;
+                set;
+            }
+        }
+
+        private delegate void StatusChangedEventCallbackType(bool statusChanged);
+        private StatusChangedEventCallbackType _statusChangedEventCallback;
+        private event EventHandler<StatusChangedEventArgs> _statusChangedEventHandler;
+
+        /// <summary>
+        /// ImfManager status changed.
+        /// </summary>
+        /// <since_tizen> 4 </since_tizen>
+        public event EventHandler<StatusChangedEventArgs> StatusChanged
+        {
+            add
+            {
+                if (_statusChangedEventHandler == null)
+                {
+                    _statusChangedEventCallback = OnStatusChanged;
+                    StatusChangedSignal().Connect(_statusChangedEventCallback);
+                }
+
+                _statusChangedEventHandler += value;
+            }
+            remove
+            {
+                _statusChangedEventHandler -= value;
+
+                if (_statusChangedEventHandler == null && _statusChangedEventCallback != null)
+                {
+                    StatusChangedSignal().Disconnect(_statusChangedEventCallback);
+                }
+            }
+        }
+
+        private void OnStatusChanged(bool statusChanged)
+        {
+            StatusChangedEventArgs e = new StatusChangedEventArgs();
+
+            e.StatusChanged = statusChanged;
+
+            if (_statusChangedEventHandler != null)
+            {
+                _statusChangedEventHandler(this, e);
+            }
+        }
+
+        /// <summary>
+        /// ImfManager status changed signal.
+        /// </summary>
+        //Please do not use! this will be internal
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public StatusSignalType StatusChangedSignal()
         {
             StatusSignalType ret = new StatusSignalType(NDalicManualPINVOKE.ImfManager_StatusChangedSignal(swigCPtr), false);
             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
             return ret;
         }
 
-        private delegate void ImfManagerResizedEventCallbackType();
+        /// <summary>
+        /// ImfManager resized event arguments.
+        /// </summary>
+        //Please do not use! this will be deprecated
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public class ImfManagerResizedEventArgs : EventArgs
+        {
+            /// <summary>
+            /// ImfManager
+            /// </summary>
+            /// <since_tizen> 3 </since_tizen>
+            public ImfManager ImfManager
+            {
+                get;
+                set;
+            }
+        }
+
+        private delegate void ImfManagerResizedEventCallbackType(IntPtr data);
         private ImfManagerResizedEventCallbackType _imfManagerResizedEventCallback;
+        private event EventHandler<ImfManagerResizedEventArgs> _imfManagerResizedEventHandler;
 
-        private event EventHandler _imfManagerResizedEventHandler;
         /// <summary>
-        /// ImfManager resized.
+        /// ImfManager resized event.
         /// </summary>
-        public event EventHandler ImfManagerResized
+        //Please do not use! this will be deprecated
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public event EventHandler<ImfManagerResizedEventArgs> ImfManagerResized
         {
             add
             {
@@ -947,29 +1471,118 @@ namespace Tizen.NUI
             }
         }
 
-        private void OnImfManagerResized()
+        private void OnImfManagerResized(IntPtr data)
         {
+            ImfManagerResizedEventArgs e = new ImfManagerResizedEventArgs();
+
+            if (data != null)
+            {
+                e.ImfManager = Registry.GetManagedBaseHandleFromNativePtr(data) as ImfManager;
+            }
+
             if (_imfManagerResizedEventHandler != null)
             {
-                _imfManagerResizedEventHandler(this, null);
+                _imfManagerResizedEventHandler(this, e);
             }
         }
 
-        internal ImfVoidSignalType ResizedSignal()
+        /// <summary>
+        /// ImfManager resized event.
+        /// </summary>
+        public class ResizedEventArgs : EventArgs
+        {
+            /// <summary>
+            /// resized.
+            /// </summary>
+            public int Resized
+            {
+                get;
+                set;
+            }
+        }
+
+        private delegate void ResizedEventCallbackType(int resized);
+        private ResizedEventCallbackType _resizedEventCallback;
+        private event EventHandler<ResizedEventArgs> _resizedEventHandler;
+
+        /// <summary>
+        /// ImfManager resized.
+        /// </summary>
+        /// <since_tizen> 4 </since_tizen>
+        public event EventHandler<ResizedEventArgs> Resized
+        {
+            add
+            {
+                if (_resizedEventHandler == null)
+                {
+                    _resizedEventCallback = OnResized;
+                    ResizedSignal().Connect(_resizedEventCallback);
+                }
+
+                _resizedEventHandler += value;
+            }
+            remove
+            {
+                _resizedEventHandler -= value;
+
+                if (_resizedEventHandler == null && _resizedEventCallback != null)
+                {
+                    ResizedSignal().Disconnect(_resizedEventCallback);
+                }
+            }
+        }
+
+        private void OnResized(int resized)
+        {
+            ResizedEventArgs e = new ResizedEventArgs();
+            e.Resized = resized;
+
+            if (_resizedEventHandler != null)
+            {
+                _resizedEventHandler(this, e);
+            }
+        }
+
+        /// <summary>
+        /// ImfManager resized signal.
+        /// </summary>
+        //Please do not use! this will be internal
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public KeyboardResizedSignalType ResizedSignal()
         {
-            ImfVoidSignalType ret = new ImfVoidSignalType(NDalicManualPINVOKE.ImfManager_ResizedSignal(swigCPtr), true);
+            KeyboardResizedSignalType ret = new KeyboardResizedSignalType(NDalicManualPINVOKE.ImfManager_ResizedSignal(swigCPtr), false);
             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
             return ret;
         }
 
-        private delegate void ImfManagerLanguageChangedEventCallbackType();
+        /// <summary>
+        /// ImfManager language changed event arguments.
+        /// </summary>
+        //Please do not use! this will be deprecated
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public class ImfManagerLanguageChangedEventArgs : EventArgs
+        {
+            /// <summary>
+            /// ImfManager
+            /// </summary>
+            /// <since_tizen> 3 </since_tizen>
+            public ImfManager ImfManager
+            {
+                get;
+                set;
+            }
+        }
+
+        private delegate void ImfManagerLanguageChangedEventCallbackType(IntPtr data);
         private ImfManagerLanguageChangedEventCallbackType _imfManagerLanguageChangedEventCallback;
+        private event EventHandler<ImfManagerLanguageChangedEventArgs> _imfManagerLanguageChangedEventHandler;
 
-        private event EventHandler _imfManagerLanguageChangedEventHandler;
         /// <summary>
-        /// ImfManager language changed.
+        /// ImfManager language changed event.
         /// </summary>
-        public event EventHandler ImfManagerLanguageChanged
+        //Please do not use! this will be deprecated
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public event EventHandler<ImfManagerLanguageChangedEventArgs> ImfManagerLanguageChanged
         {
             add
             {
@@ -992,17 +1605,86 @@ namespace Tizen.NUI
             }
         }
 
-        private void OnImfManagerLanguageChanged()
+        private void OnImfManagerLanguageChanged(IntPtr data)
         {
+            ImfManagerLanguageChangedEventArgs e = new ImfManagerLanguageChangedEventArgs();
+
+            if (data != null)
+            {
+                e.ImfManager = Registry.GetManagedBaseHandleFromNativePtr(data) as ImfManager;
+            }
+
             if (_imfManagerLanguageChangedEventHandler != null)
             {
-                _imfManagerLanguageChangedEventHandler(this, null);
+                _imfManagerLanguageChangedEventHandler(this, e);
             }
         }
 
-        internal ImfVoidSignalType LanguageChangedSignal()
+        /// <summary>
+        /// ImfManager language changed event args.
+        /// </summary>
+        public class LanguageChangedEventArgs : EventArgs
         {
-            ImfVoidSignalType ret = new ImfVoidSignalType(NDalicManualPINVOKE.ImfManager_LanguageChangedSignal(swigCPtr), true);
+            /// <summary>
+            /// language changed.
+            /// </summary>
+            public int LanguageChanged
+            {
+                get;
+                set;
+            }
+        }
+
+        private delegate void LanguageChangedEventCallbackType(int languageChanged);
+        private LanguageChangedEventCallbackType _languageChangedEventCallback;
+        private event EventHandler<LanguageChangedEventArgs> _languageChangedEventHandler;
+
+        /// <summary>
+        /// ImfManager language changed.
+        /// </summary>
+        /// <since_tizen> 4 </since_tizen>
+        public event EventHandler<LanguageChangedEventArgs> LanguageChanged
+        {
+            add
+            {
+                if (_languageChangedEventHandler == null)
+                {
+                    _languageChangedEventCallback = OnLanguageChanged;
+                    LanguageChangedSignal().Connect(_languageChangedEventCallback);
+                }
+
+                _languageChangedEventHandler += value;
+            }
+            remove
+            {
+                _languageChangedEventHandler -= value;
+
+                if (_languageChangedEventHandler == null && _languageChangedEventCallback != null)
+                {
+                    LanguageChangedSignal().Disconnect(_languageChangedEventCallback);
+                }
+            }
+        }
+
+        private void OnLanguageChanged(int languageChanged)
+        {
+            LanguageChangedEventArgs e = new LanguageChangedEventArgs();
+            e.LanguageChanged = languageChanged;
+
+            if (_languageChangedEventHandler != null)
+            {
+                _languageChangedEventHandler(this, e);
+            }
+        }
+
+        /// <summary>
+        /// ImfManager language changed signal.
+        /// </summary>
+        //Please do not use! this will be internal
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public LanguageChangedSignalType LanguageChangedSignal()
+        {
+            LanguageChangedSignalType ret = new LanguageChangedSignalType(NDalicManualPINVOKE.ImfManager_LanguageChangedSignal(swigCPtr), false);
             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
             return ret;
         }
@@ -1010,8 +1692,12 @@ namespace Tizen.NUI
         /// <summary>
         /// ImfManager keyboard type changed event arguments.
         /// </summary>
-        public class ImfKeyboardTypeChangedEventArgs : EventArgs
+        public class KeyboardTypeChangedEventArgs : EventArgs
         {
+            /// <summary>
+            /// ImfManager keyboard type
+            /// </summary>
+            /// <since_tizen> 3 </since_tizen>
             public KeyboardType KeyboardType
             {
                 get;
@@ -1019,45 +1705,46 @@ namespace Tizen.NUI
             }
         }
 
-        private delegate void ImfKeyboardTypeChangedEventCallbackType(KeyboardType type);
-        private ImfKeyboardTypeChangedEventCallbackType _imfKeyboardTypeChangedEventCallback;
+        private delegate void KeyboardTypeChangedEventCallbackType(KeyboardType type);
+        private KeyboardTypeChangedEventCallbackType _keyboardTypeChangedEventCallback;
+        private event EventHandler<KeyboardTypeChangedEventArgs> _keyboardTypeChangedEventHandler;
 
-        private event EventHandler<ImfKeyboardTypeChangedEventArgs> _imfKeyboardTypeChangedEventHandler;
         /// <summary>
         /// ImfManager keyboard type changed.
         /// </summary>
-        public event EventHandler<ImfKeyboardTypeChangedEventArgs> ImfKeyboardTypeChanged
+        /// <since_tizen> 4 </since_tizen>
+        public event EventHandler<KeyboardTypeChangedEventArgs> KeyboardTypeChanged
         {
             add
             {
-                if (_imfKeyboardTypeChangedEventHandler == null)
+                if (_keyboardTypeChangedEventHandler == null)
                 {
-                    _imfKeyboardTypeChangedEventCallback = OnImfKeyboardTypeChanged;
-                    KeyboardTypeChangedSignal().Connect(_imfKeyboardTypeChangedEventCallback);
+                    _keyboardTypeChangedEventCallback = OnKeyboardTypeChanged;
+                    KeyboardTypeChangedSignal().Connect(_keyboardTypeChangedEventCallback);
                 }
 
-                _imfKeyboardTypeChangedEventHandler += value;
+                _keyboardTypeChangedEventHandler += value;
             }
             remove
             {
-                _imfKeyboardTypeChangedEventHandler -= value;
+                _keyboardTypeChangedEventHandler -= value;
 
-                if (_imfKeyboardTypeChangedEventHandler == null && _imfKeyboardTypeChangedEventCallback != null)
+                if (_keyboardTypeChangedEventHandler == null && _keyboardTypeChangedEventCallback != null)
                 {
-                    KeyboardTypeChangedSignal().Disconnect(_imfKeyboardTypeChangedEventCallback);
+                    KeyboardTypeChangedSignal().Disconnect(_keyboardTypeChangedEventCallback);
                 }
             }
         }
 
-        private void OnImfKeyboardTypeChanged(KeyboardType type)
+        private void OnKeyboardTypeChanged(KeyboardType type)
         {
-            ImfKeyboardTypeChangedEventArgs e = new ImfKeyboardTypeChangedEventArgs();
+            KeyboardTypeChangedEventArgs e = new KeyboardTypeChangedEventArgs();
 
             e.KeyboardType = type;
 
-            if (_imfKeyboardTypeChangedEventHandler != null)
+            if (_keyboardTypeChangedEventHandler != null)
             {
-                _imfKeyboardTypeChangedEventHandler(this, e);
+                _keyboardTypeChangedEventHandler(this, e);
             }
         }
 
@@ -1069,8 +1756,9 @@ namespace Tizen.NUI
         }
 
         /// <summary>
-        /// The direction of text.
+        /// The direction of the text.
         /// </summary>
+        /// <since_tizen> 3 </since_tizen>
         public enum TextDirection
         {
             /// <summary>
@@ -1086,6 +1774,7 @@ namespace Tizen.NUI
         /// <summary>
         /// Events that are generated by the IMF.
         /// </summary>
+        /// <since_tizen> 4 </since_tizen>
         public enum ImfEvent
         {
             /// <summary>
@@ -1097,15 +1786,15 @@ namespace Tizen.NUI
             /// </summary>
             Preedit,
             /// <summary>
-            /// Commit recieved.
+            /// Commit received.
             /// </summary>
             Commit,
             /// <summary>
-            /// Event to delete a range of characters from the string.
+            /// An event to delete a range of characters from the string.
             /// </summary>
             DeleteSurrounding,
             /// <summary>
-            /// Event to query string and cursor position.
+            /// An event to query string and the cursor position.
             /// </summary>
             GetSurrounding,
             /// <summary>
@@ -1115,8 +1804,9 @@ namespace Tizen.NUI
         }
 
         /// <summary>
-        /// Enumeration for state of the input panel.
+        /// Enumeration for the state of the input panel.
         /// </summary>
+        /// <since_tizen> 4 </since_tizen>
         public enum State
         {
             /// <summary>
@@ -1138,12 +1828,13 @@ namespace Tizen.NUI
         }
 
         /// <summary>
-        /// Enumeration for the type of Keyboard.
+        /// Enumeration for the types of keyboard.
         /// </summary>
+        /// <since_tizen> 4 </since_tizen>
         public enum KeyboardType
         {
             /// <summary>
-            /// Software keyboard (Virtual keyboard) is default.
+            /// Software keyboard (virtual keyboard) is default.
             /// </summary>
             SoftwareKeyboard,
             /// <summary>
@@ -1152,4 +1843,4 @@ namespace Tizen.NUI
             HardwareKeyboard
         }
     }
-}
+}
\ No newline at end of file