DALi C# binding - EventHandler Support 90/85490/15
authorRavi Nanjundappa <nravi.n@samsung.com>
Thu, 25 Aug 2016 10:04:38 +0000 (15:34 +0530)
committerRichard Huang <r.huang@samsung.com>
Mon, 12 Sep 2016 17:02:26 +0000 (18:02 +0100)
Added EvenHandler support for AccessibilityManager, Image, Popup, Stage, Actor,
ItemView, PropertyNotification, StyleManager, Animation,  KeyboardFocusManager,
RenderTask, Tapgesture, Application, Longpressgesture, ResourceImage, TextEditor,
Builder, ObjectRegistry, Scrollable, TextField, Button, Pageturnview, Scrollbar,
Timer, Control, Pangesture, ScrollView, VideoView, GaussianBlurView, Pinchgesture
and Slider classes.

By this, we use the normal C# way of adding EventHandler as delegates to user apps
and also hide IntPtr getting exposed to Users/app developers.
For ex:
(1) _application.Init += new Dali.AUIApplicationInitEventHandler(Initialize);
(2) _scrollView.OnRelayoutEvent += new Dali.Actor.OnRelayoutEventHandler(OnScrollViewRelayout);

Also updated the doxygen comments for the EventHandlers which will be exposed to
users/app developers.

Used verbs for event names. For example,
Actor.Touched += ;
Stage.Touched += ;
Actor.WheelMoved += ;
Actor.KeyPressed += ;
All events are changes as mentioned above.

Change-Id: I335f32381a6637c81d9c2379f69fa4d6f3e3c4c2
Signed-off-by: Ravi Nanjundappa <nravi.n@samsung.com>
41 files changed:
plugins/dali-swig/SWIG/dali-adaptor.i
plugins/dali-swig/SWIG/dali-core.i
plugins/dali-swig/SWIG/dali-operator.i
plugins/dali-swig/SWIG/dali-toolkit.i
plugins/dali-swig/SWIG/dali.i
plugins/dali-swig/SWIG/events/accessibilitymanager-event.i [new file with mode: 0644]
plugins/dali-swig/SWIG/events/actor-event.i [new file with mode: 0644]
plugins/dali-swig/SWIG/events/animation-event.i [new file with mode: 0644]
plugins/dali-swig/SWIG/events/application-event.i [new file with mode: 0644]
plugins/dali-swig/SWIG/events/builder-event.i [new file with mode: 0644]
plugins/dali-swig/SWIG/events/button-event.i [new file with mode: 0644]
plugins/dali-swig/SWIG/events/control-event.i [new file with mode: 0644]
plugins/dali-swig/SWIG/events/gaussian-blur-view-event.i [new file with mode: 0644]
plugins/dali-swig/SWIG/events/image-event.i [new file with mode: 0644]
plugins/dali-swig/SWIG/events/itemview-event.i [new file with mode: 0644]
plugins/dali-swig/SWIG/events/keyboardFocusManager-event.i [new file with mode: 0644]
plugins/dali-swig/SWIG/events/longpressgesture-event.i [new file with mode: 0644]
plugins/dali-swig/SWIG/events/objectregistry-event.i [new file with mode: 0644]
plugins/dali-swig/SWIG/events/pageturnview-event.i [new file with mode: 0644]
plugins/dali-swig/SWIG/events/pangesture-event.i [new file with mode: 0644]
plugins/dali-swig/SWIG/events/pinchgesture-event.i [new file with mode: 0644]
plugins/dali-swig/SWIG/events/popup-event.i [new file with mode: 0644]
plugins/dali-swig/SWIG/events/propertynotification-event.i [new file with mode: 0644]
plugins/dali-swig/SWIG/events/rendertask-event.i [new file with mode: 0644]
plugins/dali-swig/SWIG/events/resourceimage-event.i [new file with mode: 0644]
plugins/dali-swig/SWIG/events/scrollable-event.i [new file with mode: 0644]
plugins/dali-swig/SWIG/events/scrollbar-event.i [new file with mode: 0644]
plugins/dali-swig/SWIG/events/scrollview-event.i [new file with mode: 0644]
plugins/dali-swig/SWIG/events/slider-event.i [new file with mode: 0644]
plugins/dali-swig/SWIG/events/stage-event.i [new file with mode: 0644]
plugins/dali-swig/SWIG/events/stylemanager-event.i [new file with mode: 0644]
plugins/dali-swig/SWIG/events/tapgesture-event.i [new file with mode: 0644]
plugins/dali-swig/SWIG/events/texteditor-event.i [new file with mode: 0644]
plugins/dali-swig/SWIG/events/textfield-event.i [new file with mode: 0644]
plugins/dali-swig/SWIG/events/timer-event.i [new file with mode: 0644]
plugins/dali-swig/SWIG/events/videoview-event.i [new file with mode: 0644]
plugins/dali-swig/SWIG/signal-parameters.i
plugins/dali-swig/SWIG/signals.i
plugins/dali-swig/examples/dali-test.cs
plugins/dali-swig/examples/hello-world.cs
plugins/dali-swig/examples/scroll-view.cs

index ddd74c3..affa265 100644 (file)
   */
   public";
 
-%typemap(cscode) Dali::Application %{
-
-  private static  Application instance; // singleton
-
-  public delegate void InitDelegate();
-
-  public delegate void TerminateDelegate();
-
-  public delegate void PauseDelegate();
-
-  public delegate void ResumeDelegate();
-
-  public delegate void ResizeDelegate();
-
-  public delegate void AppControlDelegate();
-
-  public delegate void LanguageChangedDelegate();
-
-  public delegate void RegionChangedDelegate();
-
-  public delegate void BatteryLowDelegate();
-
-  public delegate void MemoryLowDelegate();
-
-  [System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
-  internal delegate void InitDelegateInternal();
-
-  [System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
-  internal delegate void TerminateDelegateInternal();
-
-  [System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
-  internal delegate void PauseDelegateInternal();
-
-  [System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
-  internal delegate void ResumeDelegateInternal();
-
-  [System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
-  internal delegate void ResizeDelegateInternal();
-
-  [System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
-  internal delegate void AppControlDelegateInternal();
-
-  [System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
-  internal delegate void LanguageChangedDelegateInternal();
-
-  [System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
-  internal delegate void RegionChangedDelegateInternal();
-
-  [System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
-  internal delegate void BatteryLowDelegateInternal();
-
-  [System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
-  internal delegate void MemoryLowDelegateInternal();
-
-  static void Initialize()
-  {
-  //   instance.InitDelegate();
-  }
-
- public static Application ApplicationFromPtr(global::System.IntPtr cPtr) {
-    Application ret = new Application(cPtr, false);
-       if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  internal void SetupDelegates() {
-    InitDelegateInternal initializeCallback = new InitDelegateInternal( Initialize );
-    System.Console.WriteLine( "InitSignal connection count");
-
-    this.InitSignal().Connect( initializeCallback );
-    //Console.WriteLine( "InitSignal connection count = " + app.InitSignal().GetConnectionCount() );
- }
-
-   public static Application NewApplication() {
-    Application ret = New(1);
-       if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
-
-    // we've got an application now connect the signals
-    ret.SetupDelegates();
-    // set the singleton
-
-    return ret;
-  }
-
-%}
-
 %typemap(in) ( int* argc, char **argv[]  ) {
 
   // Todo generate argv data from the C# args
index e941834..d787496 100644 (file)
 %rename(SizeScalePolicyType) Dali::SizeScalePolicy::Type;
 %rename(HorizontalAlignmentType) Dali::HorizontalAlignment::Type;
 %rename(VerticalAlignmentType) Dali::VerticalAlignment::Type;
+%rename(ClippingModeType) Dali::ClippingMode::Type;
 %rename(FilterModeType) Dali::FilterMode::Type;
 %rename(WrapModeType) Dali::WrapMode::Type;
 %rename(PixelFormat) Dali::Pixel::Format;
 %rename(DepthWriteModeType) Dali::DepthWriteMode::Type;
 %rename(DepthTestModeType) Dali::DepthTestMode::Type;
 %rename(DepthFunctionType) Dali::DepthFunction::Type;
+%rename(RenderModeType) Dali::RenderMode::Type;
 %rename(StencilFunctionType) Dali::StencilFunction::Type;
 %rename(StencilModeType) Dali::StencilMode::Type;
 %rename(StencilOperationType) Dali::StencilOperation::Type;
index 9554651..2029eb2 100644 (file)
       return ValueOfIndex(index);
     }
   }
+
+  public static Vector2 GetVector2FromPtr(global::System.IntPtr cPtr) {
+    Vector2 ret = new Vector2(cPtr, false);
+    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+       return ret;
+  }
+
 %}
 
 %typemap(cscode) Dali::Vector3 %{
   public static Vector3 operator+(Vector3 arg1, Vector3 arg2) {
     return arg1.Add(arg2);
   }
-  
+
   public static Vector3 operator-(Vector3 arg1, Vector3 arg2) {
     return arg1.Subtract(arg2);
   }
       return ValueOfIndex(index);
     }
   }
+
+  public static Vector3 GetVector3FromPtr(global::System.IntPtr cPtr) {
+    Vector3 ret = new Vector3(cPtr, false);
+    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+       return ret;
+  }
+
 %}
 
 %typemap(cscode) Dali::Vector4 %{
       return ValueOfIndex(index);
     }
   }
+
+  public static Vector4 GetVector4FromPtr(global::System.IntPtr cPtr) {
+    Vector4 ret = new Vector4(cPtr, false);
+    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+       return ret;
+  }
+
 %}
 
 %typemap(cscode) Dali::Matrix %{
index 63c28f6..16040a8 100644 (file)
@@ -93,6 +93,7 @@
 %rename(MeshVisualShadingModeValue) Dali::Toolkit::MeshVisual::ShadingMode::Value;
 %rename(PrimitiveVisualShapeType) Dali::Toolkit::PrimitiveVisual::Shape::Type;
 %rename(PRIMITIVE_VISUAL_COLOR) Dali::Toolkit::PrimitiveVisual::Property::COLOR;
+%rename(PRIMITIVE_VISUAL_MIX_COLOR) Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
 %rename(PRIMITIVE_VISUAL_LIGHT_POSITION) Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
 %rename(VISUAL_PROPERTY_TYPE) Dali::Toolkit::Visual::Property::TYPE;
 %rename(VISUAL_PROPERTY_SHADER) Dali::Toolkit::Visual::Property::SHADER;
 %rename(IMAGE_VISUAL_DESIRED_HEIGHT) Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
 %rename(IMAGE_VISUAL_SYNCHRONOUS_LOADING) Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
 %rename(IMAGE_VISUAL_BORDER_ONLY) Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
+%rename(COLOR_VISUAL_MIX_COLOR) Dali::Toolkit::Color::Visual::Property::MIX_COLOR;
 
 %csconstvalue("PropertyRanges.PROPERTY_REGISTRATION_START_INDEX") PROPERTY_START_INDEX;
 %csconstvalue("Control.PropertyRange.PROPERTY_START_INDEX+1000") PROPERTY_END_INDEX;
index 542ed73..fc97545 100644 (file)
@@ -172,6 +172,38 @@ using namespace Dali::Toolkit;
 
 %include signal-parameters.i
 %include signals.i
+
+%include events/actor-event.i
+%include events/accessibilitymanager-event.i
+%include events/application-event.i
+%include events/animation-event.i
+%include events/button-event.i
+%include events/builder-event.i
+%include events/control-event.i
+%include events/gaussian-blur-view-event.i
+%include events/image-event.i
+%include events/itemview-event.i
+%include events/keyboardFocusManager-event.i
+%include events/objectregistry-event.i
+%include events/popup-event.i
+%include events/pinchgesture-event.i
+%include events/pageturnview-event.i
+%include events/pangesture-event.i
+%include events/propertynotification-event.i
+%include events/longpressgesture-event.i
+%include events/resourceimage-event.i
+%include events/scrollable-event.i
+%include events/scrollbar-event.i
+%include events/scrollview-event.i
+%include events/slider-event.i
+%include events/stage-event.i
+%include events/stylemanager-event.i
+%include events/tapgesture-event.i
+%include events/texteditor-event.i
+%include events/textfield-event.i
+%include events/timer-event.i
+%include events/videoview-event.i
+
 %include dali-operator.i
 %include dali-core.i
 %include dali-adaptor.i
diff --git a/plugins/dali-swig/SWIG/events/accessibilitymanager-event.i b/plugins/dali-swig/SWIG/events/accessibilitymanager-event.i
new file mode 100644 (file)
index 0000000..fa988c9
--- /dev/null
@@ -0,0 +1,2376 @@
+/*
+ * Copyright (c) 2016 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.
+ *
+ */
+
+%define ACCESSIBILITY_EVENTHANDLER_TYPEMAP_EVENTARG(NameSpace, ClassName)
+  %typemap(csimports) NameSpace::ClassName %{
+    using System;
+    using System.Runtime.InteropServices;
+%}
+
+%enddef
+
+
+%define ACCESSIBILITY_EVENTHANDLER_TYPEMAP_HELPER(NameSpace, ClassName)
+  %typemap(cscode) NameSpace::ClassName %{
+
+
+    /**
+      * @brief Event arguments that passed via StatusChanged signal
+      *
+      */
+    public class StatusChangedEventArgs : EventArgs
+    {
+      private AccessibilityManager _accessibilityManager;
+
+      public AccessibilityManager AccessibilityManager
+      {
+        get
+        {
+          return _accessibilityManager;
+        }
+        set
+        {
+          _accessibilityManager = value;
+        }
+      }
+    }
+
+    /**
+      * @brief Event arguments that passed via ActionNext signal
+      *
+      */
+    public class ActionNextEventArgs : EventArgs
+    {
+      private AccessibilityManager _accessibilityManager;
+
+      public AccessibilityManager AccessibilityManager
+      {
+        get
+        {
+          return _accessibilityManager;
+        }
+        set
+        {
+          _accessibilityManager = value;
+        }
+      }
+    }
+
+    /**
+      * @brief Event arguments that passed via ActionPrevious signal
+      *
+      */
+    public class ActionPreviousEventArgs : EventArgs
+    {
+      private AccessibilityManager _accessibilityManager;
+
+      public AccessibilityManager AccessibilityManager
+      {
+        get
+        {
+          return _accessibilityManager;
+        }
+        set
+        {
+          _accessibilityManager = value;
+        }
+      }
+    }
+
+    /**
+      * @brief Event arguments that passed via ActionActivate signal
+      *
+      */
+    public class ActionActivateEventArgs : EventArgs
+    {
+      private AccessibilityManager _accessibilityManager;
+
+      public AccessibilityManager AccessibilityManager
+      {
+        get
+        {
+          return _accessibilityManager;
+        }
+        set
+        {
+          _accessibilityManager = value;
+        }
+      }
+    }
+
+    /**
+      * @brief Event arguments that passed via ActionRead signal
+      *
+      */
+    public class ActionReadEventArgs : EventArgs
+    {
+      private AccessibilityManager _accessibilityManager;
+
+      public AccessibilityManager AccessibilityManager
+      {
+        get
+        {
+          return _accessibilityManager;
+        }
+        set
+        {
+          _accessibilityManager = value;
+        }
+      }
+    }
+
+    /**
+      * @brief Event arguments that passed via ActionOver signal
+      *
+      */
+    public class ActionOverEventArgs : EventArgs
+    {
+      private AccessibilityManager _accessibilityManager;
+
+      public AccessibilityManager AccessibilityManager
+      {
+        get
+        {
+          return _accessibilityManager;
+        }
+        set
+        {
+          _accessibilityManager = value;
+        }
+      }
+    }
+
+    /**
+      * @brief Event arguments that passed via ActionReadNext signal
+      *
+      */
+    public class ActionReadNextEventArgs : EventArgs
+    {
+      private AccessibilityManager _accessibilityManager;
+
+      public AccessibilityManager AccessibilityManager
+      {
+        get
+        {
+          return _accessibilityManager;
+        }
+        set
+        {
+          _accessibilityManager = value;
+        }
+      }
+    }
+
+    /**
+      * @brief Event arguments that passed via ActionReadPrevious signal
+      *
+      */
+    public class ActionReadPreviousEventArgs : EventArgs
+    {
+      private AccessibilityManager _accessibilityManager;
+
+      public AccessibilityManager AccessibilityManager
+      {
+        get
+        {
+          return _accessibilityManager;
+        }
+        set
+        {
+          _accessibilityManager = value;
+        }
+      }
+    }
+
+    /**
+      * @brief Event arguments that passed via ActionUp signal
+      *
+      */
+    public class ActionUpEventArgs : EventArgs
+    {
+      private AccessibilityManager _accessibilityManager;
+
+      public AccessibilityManager AccessibilityManager
+      {
+        get
+        {
+          return _accessibilityManager;
+        }
+        set
+        {
+          _accessibilityManager = value;
+        }
+      }
+    }
+
+    /**
+      * @brief Event arguments that passed via ActionDown signal
+      *
+      */
+    public class ActionDownEventArgs : EventArgs
+    {
+      private AccessibilityManager _accessibilityManager;
+
+      public AccessibilityManager AccessibilityManager
+      {
+        get
+        {
+          return _accessibilityManager;
+        }
+        set
+        {
+          _accessibilityManager = value;
+        }
+      }
+    }
+
+    /**
+      * @brief Event arguments that passed via ActionClearFocus signal
+      *
+      */
+    public class ActionClearFocusEventArgs : EventArgs
+    {
+      private AccessibilityManager _accessibilityManager;
+
+      public AccessibilityManager AccessibilityManager
+      {
+        get
+        {
+          return _accessibilityManager;
+        }
+        set
+        {
+          _accessibilityManager = value;
+        }
+      }
+    }
+
+    /**
+      * @brief Event arguments that passed via ActionBack signal
+      *
+      */
+    public class ActionBackEventArgs : EventArgs
+    {
+      private AccessibilityManager _accessibilityManager;
+
+      public AccessibilityManager AccessibilityManager
+      {
+        get
+        {
+          return _accessibilityManager;
+        }
+        set
+        {
+          _accessibilityManager = value;
+        }
+      }
+    }
+
+    /**
+      * @brief Event arguments that passed via ActionScrollUp signal
+      *
+      */
+    public class ActionScrollUpEventArgs : EventArgs
+    {
+      private AccessibilityManager _accessibilityManager;
+
+      public AccessibilityManager AccessibilityManager
+      {
+        get
+        {
+          return _accessibilityManager;
+        }
+        set
+        {
+          _accessibilityManager = value;
+        }
+      }
+    }
+
+    /**
+      * @brief Event arguments that passed via ActionScrollDown signal
+      *
+      */
+    public class ActionScrollDownEventArgs : EventArgs
+    {
+      private AccessibilityManager _accessibilityManager;
+
+      public AccessibilityManager AccessibilityManager
+      {
+        get
+        {
+          return _accessibilityManager;
+        }
+        set
+        {
+          _accessibilityManager = value;
+        }
+      }
+    }
+
+    /**
+      * @brief Event arguments that passed via ActionPageLeft signal
+      *
+      */
+    public class ActionPageLeftEventArgs : EventArgs
+    {
+      private AccessibilityManager _accessibilityManager;
+
+      public AccessibilityManager AccessibilityManager
+      {
+        get
+        {
+          return _accessibilityManager;
+        }
+        set
+        {
+          _accessibilityManager = value;
+        }
+      }
+    }
+
+    /**
+      * @brief Event arguments that passed via ActionPageRight signal
+      *
+      */
+    public class ActionPageRightEventArgs : EventArgs
+    {
+      private AccessibilityManager _accessibilityManager;
+
+      public AccessibilityManager AccessibilityManager
+      {
+        get
+        {
+          return _accessibilityManager;
+        }
+        set
+        {
+          _accessibilityManager = value;
+        }
+      }
+    }
+
+    /**
+      * @brief Event arguments that passed via ActionPageUp signal
+      *
+      */
+    public class ActionPageUpEventArgs : EventArgs
+    {
+      private AccessibilityManager _accessibilityManager;
+
+      public AccessibilityManager AccessibilityManager
+      {
+        get
+        {
+          return _accessibilityManager;
+        }
+        set
+        {
+          _accessibilityManager = value;
+        }
+      }
+    }
+
+    /**
+      * @brief Event arguments that passed via ActionPageDown signal
+      *
+      */
+    public class ActionPageDownEventArgs : EventArgs
+    {
+      private AccessibilityManager _accessibilityManager;
+
+      public AccessibilityManager AccessibilityManager
+      {
+        get
+        {
+          return _accessibilityManager;
+        }
+        set
+        {
+          _accessibilityManager = value;
+        }
+      }
+    }
+
+    /**
+      * @brief Event arguments that passed via ActionMoveToFirst signal
+      *
+      */
+    public class ActionMoveToFirstEventArgs : EventArgs
+    {
+      private AccessibilityManager _accessibilityManager;
+
+      public AccessibilityManager AccessibilityManager
+      {
+        get
+        {
+          return _accessibilityManager;
+        }
+        set
+        {
+          _accessibilityManager = value;
+        }
+      }
+    }
+
+    /**
+      * @brief Event arguments that passed via ActionMoveToLast signal
+      *
+      */
+    public class ActionMoveToLastEventArgs : EventArgs
+    {
+      private AccessibilityManager _accessibilityManager;
+
+      public AccessibilityManager AccessibilityManager
+      {
+        get
+        {
+          return _accessibilityManager;
+        }
+        set
+        {
+          _accessibilityManager = value;
+        }
+      }
+    }
+
+    /**
+      * @brief Event arguments that passed via ActionReadFromTop signal
+      *
+      */
+    public class ActionReadFromTopEventArgs : EventArgs
+    {
+      private AccessibilityManager _accessibilityManager;
+
+      public AccessibilityManager AccessibilityManager
+      {
+        get
+        {
+          return _accessibilityManager;
+        }
+        set
+        {
+          _accessibilityManager = value;
+        }
+      }
+    }
+
+    /**
+      * @brief Event arguments that passed via ActionReadFromNext signal
+      *
+      */
+    public class ActionReadFromNextEventArgs : EventArgs
+    {
+      private AccessibilityManager _accessibilityManager;
+
+      public AccessibilityManager AccessibilityManager
+      {
+        get
+        {
+          return _accessibilityManager;
+        }
+        set
+        {
+          _accessibilityManager = value;
+        }
+      }
+    }
+
+    /**
+      * @brief Event arguments that passed via ActionZoom signal
+      *
+      */
+    public class ActionZoomEventArgs : EventArgs
+    {
+      private AccessibilityManager _accessibilityManager;
+
+      public AccessibilityManager AccessibilityManager
+      {
+        get
+        {
+          return _accessibilityManager;
+        }
+        set
+        {
+          _accessibilityManager = value;
+        }
+      }
+    }
+
+    /**
+      * @brief Event arguments that passed via ActionReadIndicatorInformation signal
+      *
+      */
+    public class ActionReadIndicatorInformationEventArgs : EventArgs
+    {
+      private AccessibilityManager _accessibilityManager;
+
+      public AccessibilityManager AccessibilityManager
+      {
+        get
+        {
+          return _accessibilityManager;
+        }
+        set
+        {
+          _accessibilityManager = value;
+        }
+      }
+    }
+
+    /**
+      * @brief Event arguments that passed via ActionReadPauseResume signal
+      *
+      */
+    public class ActionReadPauseResumeEventArgs : EventArgs
+    {
+      private AccessibilityManager _accessibilityManager;
+
+      public AccessibilityManager AccessibilityManager
+      {
+        get
+        {
+          return _accessibilityManager;
+        }
+        set
+        {
+          _accessibilityManager = value;
+        }
+      }
+    }
+
+    /**
+      * @brief Event arguments that passed via ActionStartStop signal
+      *
+      */
+    public class ActionStartStopEventArgs : EventArgs
+    {
+      private AccessibilityManager _accessibilityManager;
+
+      public AccessibilityManager AccessibilityManager
+      {
+        get
+        {
+          return _accessibilityManager;
+        }
+        set
+        {
+          _accessibilityManager = value;
+        }
+      }
+    }
+
+    /**
+      * @brief Event arguments that passed via ActionScroll signal
+      *
+      */
+    public class ActionScrollEventArgs : EventArgs
+    {
+      private AccessibilityManager _accessibilityManager;
+      private TouchEvent _touchEvent;
+
+      public AccessibilityManager AccessibilityManager
+      {
+        get
+        {
+          return _accessibilityManager;
+        }
+        set
+        {
+          _accessibilityManager = value;
+        }
+      }
+
+      public TouchEvent TouchEvent
+      {
+        get
+        {
+          return _touchEvent;
+        }
+        set
+        {
+          _touchEvent = value;
+        }
+      }
+    }
+
+    /**
+      * @brief Event arguments that passed via ActionPageUp signal
+      *
+      */
+    public class FocusChangedEventArgs : EventArgs
+    {
+      private Actor _actorCurrent;
+      private Actor _actorNext;
+
+      public Actor ActorCurrent
+      {
+        get
+        {
+          return _actorCurrent;
+        }
+        set
+        {
+          _actorCurrent = value;
+        }
+      }
+
+      public Actor ActorNext
+      {
+        get
+        {
+          return _actorNext;
+        }
+        set
+        {
+          _actorNext = value;
+        }
+      }
+    }
+
+    /**
+      * @brief Event arguments that passed via FocusedActorActivated signal
+      *
+      */
+    public class FocusedActorActivatedEventArgs : EventArgs
+    {
+      private Actor _actor;
+
+
+      public Actor Actor
+      {
+        get
+        {
+          return _actor;
+        }
+        set
+        {
+          _actor = value;
+        }
+      }
+    }
+
+    /**
+      * @brief Event arguments that passed via FocusOvershot signal
+      *
+      */
+    public class FocusOvershotEventArgs : EventArgs
+    {
+      private Actor _currentFocusedActor;
+      private AccessibilityManager.FocusOvershotDirection _focusOvershotDirection;
+
+      public Actor CurrentFocusedActor
+      {
+        get
+        {
+          return _currentFocusedActor;
+        }
+        set
+        {
+          _currentFocusedActor = value;
+        }
+      }
+
+      public AccessibilityManager.FocusOvershotDirection FocusOvershotDirection
+      {
+        get
+        {
+          return _focusOvershotDirection;
+        }
+        set
+        {
+          _focusOvershotDirection = value;
+        }
+      }
+    }
+
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool StatusChangedEventHandler(object source, StatusChangedEventArgs e);
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool ActionNextEventHandler(object source, ActionNextEventArgs e);
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool ActionPreviousEventHandler(object source, ActionPreviousEventArgs e);
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool ActionActivateEventHandler(object source, ActionActivateEventArgs e);
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool ActionReadEventHandler(object source, ActionReadEventArgs e);
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool ActionOverEventHandler(object source, ActionOverEventArgs e);
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool ActionReadNextEventHandler(object source, ActionReadNextEventArgs e);
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool ActionReadPreviousEventHandler(object source, ActionReadPreviousEventArgs e);
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool ActionUpEventHandler(object source, ActionUpEventArgs e);
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool ActionDownEventHandler(object source, ActionDownEventArgs e);
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool ActionClearFocusEventHandler(object source, ActionClearFocusEventArgs e);
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool ActionBackEventHandler(object source, ActionBackEventArgs e);
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool ActionScrollUpEventHandler(object source, ActionScrollUpEventArgs e);
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool ActionScrollDownEventHandler(object source, ActionScrollDownEventArgs e);
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool ActionPageLeftEventHandler(object source, ActionPageLeftEventArgs e);
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool ActionPageRightEventHandler(object source, ActionPageRightEventArgs e);
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool ActionPageUpEventHandler(object source, ActionPageUpEventArgs e);
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool ActionPageDownEventHandler(object source, ActionPageDownEventArgs e);
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool ActionMoveToFirstEventHandler(object source, ActionMoveToFirstEventArgs e);
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool ActionMoveToLastEventHandler(object source, ActionMoveToLastEventArgs e);
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool ActionReadFromTopEventHandler(object source, ActionReadFromTopEventArgs e);
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool ActionReadFromNextEventHandler(object source, ActionReadFromNextEventArgs e);
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool ActionZoomEventHandler(object source, ActionZoomEventArgs e);
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool ActionReadIndicatorInformationEventHandler(object source, ActionReadIndicatorInformationEventArgs e);
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool ActionReadPauseResumeEventHandler(object source, ActionReadPauseResumeEventArgs e);
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool ActionStartStopEventHandler(object source, ActionStartStopEventArgs e);
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool ActionScrollEventHandler(object source, ActionScrollEventArgs e);
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate void FocusChangedEventHandler(object source, FocusChangedEventArgs e);
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate void FocusedActorActivatedEventHandler(object source, FocusedActorActivatedEventArgs e);
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate void FocusOvershotEventHandler(object source, FocusOvershotEventArgs e);
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    private delegate bool StatusChangedEventCallbackDelegate(IntPtr accessibilityManager);
+    private StatusChangedEventHandler _accessibilityManagerStatusChangedEventHandler;
+    private StatusChangedEventCallbackDelegate _accessibilityManagerStatusChangedEventCallbackDelegate;
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    private delegate bool ActionNextEventCallbackDelegate(IntPtr accessibilityManager);
+    private ActionNextEventHandler _accessibilityManagerActionNextEventHandler;
+    private ActionNextEventCallbackDelegate _accessibilityManagerActionNextEventCallbackDelegate;
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    private delegate bool ActionPreviousEventCallbackDelegate(IntPtr accessibilityManager);
+    private ActionPreviousEventHandler _accessibilityManagerActionPreviousEventHandler;
+    private ActionPreviousEventCallbackDelegate _accessibilityManagerActionPreviousEventCallbackDelegate;
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    private delegate bool ActionActivateEventCallbackDelegate(IntPtr accessibilityManager);
+    private ActionActivateEventHandler _accessibilityManagerActionActivateEventHandler;
+    private ActionActivateEventCallbackDelegate _accessibilityManagerActionActivateEventCallbackDelegate;
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    private delegate bool ActionReadEventCallbackDelegate(IntPtr accessibilityManager);
+    private ActionReadEventHandler _accessibilityManagerActionReadEventHandler;
+    private ActionReadEventCallbackDelegate _accessibilityManagerActionReadEventCallbackDelegate;
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    private delegate bool ActionOverEventCallbackDelegate(IntPtr accessibilityManager);
+    private ActionOverEventHandler _accessibilityManagerActionOverEventHandler;
+    private ActionOverEventCallbackDelegate _accessibilityManagerActionOverEventCallbackDelegate;
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    private delegate bool ActionReadNextEventCallbackDelegate(IntPtr accessibilityManager);
+    private ActionReadNextEventHandler _accessibilityManagerActionReadNextEventHandler;
+    private ActionReadNextEventCallbackDelegate _accessibilityManagerActionReadNextEventCallbackDelegate;
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    private delegate bool ActionReadPreviousEventCallbackDelegate(IntPtr accessibilityManager);
+    private ActionReadPreviousEventHandler _accessibilityManagerActionReadPreviousEventHandler;
+    private ActionReadPreviousEventCallbackDelegate _accessibilityManagerActionReadPreviousEventCallbackDelegate;
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    private delegate bool ActionUpEventCallbackDelegate(IntPtr accessibilityManager);
+    private ActionUpEventHandler _accessibilityManagerActionUpEventHandler;
+    private ActionUpEventCallbackDelegate _accessibilityManagerActionUpEventCallbackDelegate;
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    private delegate bool ActionDownEventCallbackDelegate(IntPtr accessibilityManager);
+    private ActionDownEventHandler _accessibilityManagerActionDownEventHandler;
+    private ActionDownEventCallbackDelegate _accessibilityManagerActionDownEventCallbackDelegate;
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    private delegate bool ActionClearFocusEventCallbackDelegate(IntPtr accessibilityManager);
+    private ActionClearFocusEventHandler _accessibilityManagerActionClearFocusEventHandler;
+    private ActionClearFocusEventCallbackDelegate _accessibilityManagerActionClearFocusEventCallbackDelegate;
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    private delegate bool ActionBackEventCallbackDelegate(IntPtr accessibilityManager);
+    private ActionBackEventHandler _accessibilityManagerActionBackEventHandler;
+    private ActionBackEventCallbackDelegate _accessibilityManagerActionBackEventCallbackDelegate;
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    private delegate bool ActionScrollUpEventCallbackDelegate(IntPtr accessibilityManager);
+    private ActionScrollUpEventHandler _accessibilityManagerActionScrollUpEventHandler;
+    private ActionScrollUpEventCallbackDelegate _accessibilityManagerActionScrollUpEventCallbackDelegate;
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    private delegate bool ActionScrollDownEventCallbackDelegate(IntPtr accessibilityManager);
+    private ActionScrollDownEventHandler _accessibilityManagerActionScrollDownEventHandler;
+    private ActionScrollDownEventCallbackDelegate _accessibilityManagerActionScrollDownEventCallbackDelegate;
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    private delegate bool ActionPageLeftEventCallbackDelegate(IntPtr accessibilityManager);
+    private ActionPageLeftEventHandler _accessibilityManagerActionPageLeftEventHandler;
+    private ActionPageLeftEventCallbackDelegate _accessibilityManagerActionPageLeftEventCallbackDelegate;
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    private delegate bool ActionPageRightEventCallbackDelegate(IntPtr accessibilityManager);
+    private ActionPageRightEventHandler _accessibilityManagerActionPageRightEventHandler;
+    private ActionPageRightEventCallbackDelegate _accessibilityManagerActionPageRightEventCallbackDelegate;
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    private delegate bool ActionPageUpEventCallbackDelegate(IntPtr accessibilityManager);
+    private ActionPageUpEventHandler _accessibilityManagerActionPageUpEventHandler;
+    private ActionPageUpEventCallbackDelegate _accessibilityManagerActionPageUpEventCallbackDelegate;
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    private delegate bool ActionPageDownEventCallbackDelegate(IntPtr accessibilityManager);
+    private ActionPageDownEventHandler _accessibilityManagerActionPageDownEventHandler;
+    private ActionPageDownEventCallbackDelegate _accessibilityManagerActionPageDownEventCallbackDelegate;
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    private delegate bool ActionMoveToFirstEventCallbackDelegate(IntPtr accessibilityManager);
+    private ActionMoveToFirstEventHandler _accessibilityManagerActionMoveToFirstEventHandler;
+    private ActionMoveToFirstEventCallbackDelegate _accessibilityManagerActionMoveToFirstEventCallbackDelegate;
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    private delegate bool ActionMoveToLastEventCallbackDelegate(IntPtr accessibilityManager);
+    private ActionMoveToLastEventHandler _accessibilityManagerActionMoveToLastEventHandler;
+    private ActionMoveToLastEventCallbackDelegate _accessibilityManagerActionMoveToLastEventCallbackDelegate;
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    private delegate bool ActionReadFromTopEventCallbackDelegate(IntPtr accessibilityManager);
+    private ActionReadFromTopEventHandler _accessibilityManagerActionReadFromTopEventHandler;
+    private ActionReadFromTopEventCallbackDelegate _accessibilityManagerActionReadFromTopEventCallbackDelegate;
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    private delegate bool ActionReadFromNextEventCallbackDelegate(IntPtr accessibilityManager);
+    private ActionReadFromNextEventHandler _accessibilityManagerActionReadFromNextEventHandler;
+    private ActionReadFromNextEventCallbackDelegate _accessibilityManagerActionReadFromNextEventCallbackDelegate;
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    private delegate bool ActionZoomEventCallbackDelegate(IntPtr accessibilityManager);
+    private ActionZoomEventHandler _accessibilityManagerActionZoomEventHandler;
+    private ActionZoomEventCallbackDelegate _accessibilityManagerActionZoomEventCallbackDelegate;
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    private delegate bool ActionReadIndicatorInformationEventCallbackDelegate(IntPtr accessibilityManager);
+    private ActionReadIndicatorInformationEventHandler _accessibilityManagerActionReadIndicatorInformationEventHandler;
+    private ActionReadIndicatorInformationEventCallbackDelegate _accessibilityManagerActionReadIndicatorInformationEventCallbackDelegate;
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    private delegate bool ActionReadPauseResumeEventCallbackDelegate(IntPtr accessibilityManager);
+    private ActionReadPauseResumeEventHandler _accessibilityManagerActionReadPauseResumeEventHandler;
+    private ActionReadPauseResumeEventCallbackDelegate _accessibilityManagerActionReadPauseResumeEventCallbackDelegate;
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    private delegate bool ActionStartStopEventCallbackDelegate(IntPtr accessibilityManager);
+    private ActionStartStopEventHandler _accessibilityManagerActionStartStopEventHandler;
+    private ActionStartStopEventCallbackDelegate _accessibilityManagerActionStartStopEventCallbackDelegate;
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    private delegate bool ActionScrollEventCallbackDelegate(IntPtr accessibilityManager, IntPtr touchEvent);
+    private ActionScrollEventHandler _accessibilityManagerActionScrollEventHandler;
+    private ActionScrollEventCallbackDelegate _accessibilityManagerActionScrollEventCallbackDelegate;
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    private delegate void FocusChangedEventCallbackDelegate(IntPtr actor1, IntPtr actor2);
+    private FocusChangedEventHandler _accessibilityManagerFocusChangedEventHandler;
+    private FocusChangedEventCallbackDelegate _accessibilityManagerFocusChangedEventCallbackDelegate;
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    private delegate void FocusedActorActivatedEventCallbackDelegate(IntPtr actor);
+    private FocusedActorActivatedEventHandler _accessibilityManagerFocusedActorActivatedEventHandler;
+    private FocusedActorActivatedEventCallbackDelegate _accessibilityManagerFocusedActorActivatedEventCallbackDelegate;
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    private delegate void FocusOvershotEventCallbackDelegate(IntPtr currentFocusedActor, AccessibilityManager.FocusOvershotDirection direction);
+    private FocusOvershotEventHandler _accessibilityManagerFocusOvershotEventHandler;
+    private FocusOvershotEventCallbackDelegate _accessibilityManagerFocusOvershotEventCallbackDelegate;
+
+    public event StatusChangedEventHandler StatusChanged
+    {
+      add
+      {
+        lock(this)
+        {
+          // Restricted to only one listener
+          if (_accessibilityManagerStatusChangedEventHandler == null)
+          {
+            _accessibilityManagerStatusChangedEventHandler += value;
+
+            _accessibilityManagerStatusChangedEventCallbackDelegate = new StatusChangedEventCallbackDelegate(OnStatusChanged);
+            this.StatusChangedSignal().Connect(_accessibilityManagerStatusChangedEventCallbackDelegate);
+          }
+        }
+      }
+
+      remove
+      {
+        lock(this)
+        {
+          if (_accessibilityManagerStatusChangedEventHandler != null)
+          {
+            this.StatusChangedSignal().Disconnect(_accessibilityManagerStatusChangedEventCallbackDelegate);
+          }
+
+          _accessibilityManagerStatusChangedEventHandler -= value;
+        }
+      }
+    }
+
+    // Callback for AccessibilityManager StatusChangedSignal
+    private bool OnStatusChanged(IntPtr data)
+    {
+      StatusChangedEventArgs e = new StatusChangedEventArgs();
+
+      // Populate all members of "e" (StatusChangedEventArgs) with real data
+      e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
+
+      if (_accessibilityManagerStatusChangedEventHandler != null)
+      {
+        //here we send all data to user event handlers
+        return _accessibilityManagerStatusChangedEventHandler(this, e);
+      }
+      return false;
+    }
+
+    public event ActionNextEventHandler ActionNext
+    {
+      add
+      {
+        lock(this)
+        {
+          // Restricted to only one listener
+          if (_accessibilityManagerActionNextEventHandler == null)
+          {
+            _accessibilityManagerActionNextEventHandler += value;
+
+            _accessibilityManagerActionNextEventCallbackDelegate = new ActionNextEventCallbackDelegate(OnActionNext);
+            this.ActionNextSignal().Connect(_accessibilityManagerActionNextEventCallbackDelegate);
+          }
+        }
+      }
+
+      remove
+      {
+        lock(this)
+        {
+          if (_accessibilityManagerActionNextEventHandler != null)
+          {
+            this.ActionNextSignal().Disconnect(_accessibilityManagerActionNextEventCallbackDelegate);
+          }
+
+          _accessibilityManagerActionNextEventHandler -= value;
+        }
+      }
+    }
+
+    // Callback for AccessibilityManager ActionNextSignal
+    private bool OnActionNext(IntPtr data)
+    {
+      ActionNextEventArgs e = new ActionNextEventArgs();
+
+      // Populate all members of "e" (ActionNextEventArgs) with real data
+      e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
+
+      if (_accessibilityManagerActionNextEventHandler != null)
+      {
+        //here we send all data to user event handlers
+        return _accessibilityManagerActionNextEventHandler(this, e);
+      }
+      return false;
+    }
+
+    public event ActionPreviousEventHandler ActionPrevious
+    {
+      add
+      {
+        lock(this)
+        {
+          // Restricted to only one listener
+          if (_accessibilityManagerActionPreviousEventHandler == null)
+          {
+            _accessibilityManagerActionPreviousEventHandler += value;
+
+            _accessibilityManagerActionPreviousEventCallbackDelegate = new ActionPreviousEventCallbackDelegate(OnActionPrevious);
+            this.ActionPreviousSignal().Connect(_accessibilityManagerActionPreviousEventCallbackDelegate);
+          }
+        }
+      }
+
+      remove
+      {
+        lock(this)
+        {
+          if (_accessibilityManagerActionPreviousEventHandler != null)
+          {
+            this.ActionPreviousSignal().Disconnect(_accessibilityManagerActionPreviousEventCallbackDelegate);
+          }
+
+          _accessibilityManagerActionPreviousEventHandler -= value;
+        }
+      }
+    }
+
+    // Callback for AccessibilityManager ActionPreviousSignal
+    private bool OnActionPrevious(IntPtr data)
+    {
+      ActionPreviousEventArgs e = new ActionPreviousEventArgs();
+
+      // Populate all members of "e" (ActionPreviousEventArgs) with real data
+      e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
+
+      if (_accessibilityManagerActionPreviousEventHandler != null)
+      {
+        //here we send all data to user event handlers
+        return _accessibilityManagerActionPreviousEventHandler(this, e);
+      }
+      return false;
+    }
+
+    public event ActionActivateEventHandler ActionActivate
+    {
+      add
+      {
+        lock(this)
+        {
+          // Restricted to only one listener
+          if (_accessibilityManagerActionActivateEventHandler == null)
+          {
+            _accessibilityManagerActionActivateEventHandler += value;
+
+            _accessibilityManagerActionActivateEventCallbackDelegate = new ActionActivateEventCallbackDelegate(OnActionActivate);
+            this.ActionActivateSignal().Connect(_accessibilityManagerActionActivateEventCallbackDelegate);
+          }
+        }
+      }
+
+      remove
+      {
+        lock(this)
+        {
+          if (_accessibilityManagerActionActivateEventHandler != null)
+          {
+            this.ActionActivateSignal().Disconnect(_accessibilityManagerActionActivateEventCallbackDelegate);
+          }
+
+          _accessibilityManagerActionActivateEventHandler -= value;
+        }
+      }
+    }
+
+    // Callback for AccessibilityManager ActionActivateSignal
+    private bool OnActionActivate(IntPtr data)
+    {
+      ActionActivateEventArgs e = new ActionActivateEventArgs();
+
+      // Populate all members of "e" (ActionActivateEventArgs) with real data
+      e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
+
+      if (_accessibilityManagerActionActivateEventHandler != null)
+      {
+        //here we send all data to user event handlers
+        return _accessibilityManagerActionActivateEventHandler(this, e);
+      }
+      return false;
+    }
+
+    public event ActionReadEventHandler ActionRead
+    {
+      add
+      {
+        lock(this)
+        {
+          // Restricted to only one listener
+          if (_accessibilityManagerActionReadEventHandler == null)
+          {
+            _accessibilityManagerActionReadEventHandler += value;
+
+            _accessibilityManagerActionReadEventCallbackDelegate = new ActionReadEventCallbackDelegate(OnActionRead);
+            this.ActionReadSignal().Connect(_accessibilityManagerActionReadEventCallbackDelegate);
+          }
+        }
+      }
+
+      remove
+      {
+        lock(this)
+        {
+          if (_accessibilityManagerActionReadEventHandler != null)
+          {
+            this.ActionReadSignal().Disconnect(_accessibilityManagerActionReadEventCallbackDelegate);
+          }
+
+          _accessibilityManagerActionReadEventHandler -= value;
+        }
+      }
+    }
+
+    // Callback for AccessibilityManager ActionReadSignal
+    private bool OnActionRead(IntPtr data)
+    {
+      ActionReadEventArgs e = new ActionReadEventArgs();
+
+      // Populate all members of "e" (ActionReadEventArgs) with real data
+      e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
+
+      if (_accessibilityManagerActionReadEventHandler != null)
+      {
+        //here we send all data to user event handlers
+        return _accessibilityManagerActionReadEventHandler(this, e);
+      }
+      return false;
+    }
+
+    public event ActionOverEventHandler ActionOver
+    {
+      add
+      {
+        lock(this)
+        {
+          // Restricted to only one listener
+          if (_accessibilityManagerActionOverEventHandler == null)
+          {
+            _accessibilityManagerActionOverEventHandler += value;
+
+            _accessibilityManagerActionOverEventCallbackDelegate = new ActionOverEventCallbackDelegate(OnActionOver);
+            this.ActionOverSignal().Connect(_accessibilityManagerActionOverEventCallbackDelegate);
+          }
+        }
+      }
+
+      remove
+      {
+        lock(this)
+        {
+          if (_accessibilityManagerActionOverEventHandler != null)
+          {
+            this.ActionOverSignal().Disconnect(_accessibilityManagerActionOverEventCallbackDelegate);
+          }
+
+          _accessibilityManagerActionOverEventHandler -= value;
+        }
+      }
+    }
+
+    // Callback for AccessibilityManager ActionOverSignal
+    private bool OnActionOver(IntPtr data)
+    {
+      ActionOverEventArgs e = new ActionOverEventArgs();
+
+      // Populate all members of "e" (ActionOverEventArgs) with real data
+      e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
+
+      if (_accessibilityManagerActionOverEventHandler != null)
+      {
+        //here we send all data to user event handlers
+        return _accessibilityManagerActionOverEventHandler(this, e);
+      }
+      return false;
+    }
+
+    public event ActionReadNextEventHandler ActionReadNext
+    {
+      add
+      {
+        lock(this)
+        {
+          // Restricted to only one listener
+          if (_accessibilityManagerActionReadNextEventHandler == null)
+          {
+            _accessibilityManagerActionReadNextEventHandler += value;
+
+            _accessibilityManagerActionReadNextEventCallbackDelegate = new ActionReadNextEventCallbackDelegate(OnActionReadNext);
+            this.ActionReadNextSignal().Connect(_accessibilityManagerActionReadNextEventCallbackDelegate);
+          }
+        }
+      }
+
+      remove
+      {
+        lock(this)
+        {
+          if (_accessibilityManagerActionReadNextEventHandler != null)
+          {
+            this.ActionReadNextSignal().Disconnect(_accessibilityManagerActionReadNextEventCallbackDelegate);
+          }
+
+          _accessibilityManagerActionReadNextEventHandler -= value;
+        }
+      }
+    }
+
+    // Callback for AccessibilityManager ActionReadNextSignal
+    private bool OnActionReadNext(IntPtr data)
+    {
+      ActionReadNextEventArgs e = new ActionReadNextEventArgs();
+
+      // Populate all members of "e" (ActionReadNextEventArgs) with real data
+      e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
+
+      if (_accessibilityManagerActionReadNextEventHandler != null)
+      {
+        //here we send all data to user event handlers
+        return _accessibilityManagerActionReadNextEventHandler(this, e);
+      }
+      return false;
+    }
+
+
+    public event ActionReadPreviousEventHandler ActionReadPrevious
+    {
+      add
+      {
+        lock(this)
+        {
+          // Restricted to only one listener
+          if (_accessibilityManagerActionReadPreviousEventHandler == null)
+          {
+            _accessibilityManagerActionReadPreviousEventHandler += value;
+
+            _accessibilityManagerActionReadPreviousEventCallbackDelegate = new ActionReadPreviousEventCallbackDelegate(OnActionReadPrevious);
+            this.ActionReadPreviousSignal().Connect(_accessibilityManagerActionReadPreviousEventCallbackDelegate);
+          }
+        }
+      }
+
+      remove
+      {
+        lock(this)
+        {
+          if (_accessibilityManagerActionReadPreviousEventHandler != null)
+          {
+            this.ActionReadPreviousSignal().Disconnect(_accessibilityManagerActionReadPreviousEventCallbackDelegate);
+          }
+
+          _accessibilityManagerActionReadPreviousEventHandler -= value;
+        }
+      }
+    }
+
+    // Callback for AccessibilityManager ActionReadPreviousSignal
+    private bool OnActionReadPrevious(IntPtr data)
+    {
+      ActionReadPreviousEventArgs e = new ActionReadPreviousEventArgs();
+
+      // Populate all members of "e" (ActionReadPreviousEventArgs) with real data
+      e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
+
+      if (_accessibilityManagerActionReadPreviousEventHandler != null)
+      {
+        //here we send all data to user event handlers
+        return _accessibilityManagerActionReadPreviousEventHandler(this, e);
+      }
+      return false;
+    }
+
+    public event ActionUpEventHandler ActionUp
+    {
+      add
+      {
+        lock(this)
+        {
+          // Restricted to only one listener
+          if (_accessibilityManagerActionUpEventHandler == null)
+          {
+            _accessibilityManagerActionUpEventHandler += value;
+
+            _accessibilityManagerActionUpEventCallbackDelegate = new ActionUpEventCallbackDelegate(OnActionUp);
+            this.ActionUpSignal().Connect(_accessibilityManagerActionUpEventCallbackDelegate);
+          }
+        }
+      }
+
+      remove
+      {
+        lock(this)
+        {
+          if (_accessibilityManagerActionUpEventHandler != null)
+          {
+            this.ActionUpSignal().Disconnect(_accessibilityManagerActionUpEventCallbackDelegate);
+          }
+
+          _accessibilityManagerActionUpEventHandler -= value;
+        }
+      }
+    }
+
+    // Callback for AccessibilityManager ActionUpSignal
+    private bool OnActionUp(IntPtr data)
+    {
+      ActionUpEventArgs e = new ActionUpEventArgs();
+
+      // Populate all members of "e" (ActionUpEventArgs) with real data
+      e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
+
+      if (_accessibilityManagerActionUpEventHandler != null)
+      {
+        //here we send all data to user event handlers
+        return _accessibilityManagerActionUpEventHandler(this, e);
+      }
+      return false;
+    }
+
+    public event ActionDownEventHandler ActionDown
+    {
+      add
+      {
+        lock(this)
+        {
+          // Restricted to only one listener
+          if (_accessibilityManagerActionDownEventHandler == null)
+          {
+            _accessibilityManagerActionDownEventHandler += value;
+
+            _accessibilityManagerActionDownEventCallbackDelegate = new ActionDownEventCallbackDelegate(OnActionDown);
+            this.ActionDownSignal().Connect(_accessibilityManagerActionDownEventCallbackDelegate);
+          }
+        }
+      }
+
+      remove
+      {
+        lock(this)
+        {
+          if (_accessibilityManagerActionDownEventHandler != null)
+          {
+            this.ActionDownSignal().Disconnect(_accessibilityManagerActionDownEventCallbackDelegate);
+          }
+
+          _accessibilityManagerActionDownEventHandler -= value;
+        }
+      }
+    }
+
+    // Callback for AccessibilityManager ActionDownSignal
+    private bool OnActionDown(IntPtr data)
+    {
+      ActionDownEventArgs e = new ActionDownEventArgs();
+
+      // Populate all members of "e" (ActionDownEventArgs) with real data
+      e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
+
+      if (_accessibilityManagerActionDownEventHandler != null)
+      {
+        //here we send all data to user event handlers
+        return _accessibilityManagerActionDownEventHandler(this, e);
+      }
+      return false;
+    }
+
+    public event ActionClearFocusEventHandler ActionClearFocus
+    {
+      add
+      {
+        lock(this)
+        {
+          // Restricted to only one listener
+          if (_accessibilityManagerActionClearFocusEventHandler == null)
+          {
+            _accessibilityManagerActionClearFocusEventHandler += value;
+
+            _accessibilityManagerActionClearFocusEventCallbackDelegate = new ActionClearFocusEventCallbackDelegate(OnActionClearFocus);
+            this.ActionClearFocusSignal().Connect(_accessibilityManagerActionClearFocusEventCallbackDelegate);
+          }
+        }
+      }
+
+      remove
+      {
+        lock(this)
+        {
+          if (_accessibilityManagerActionClearFocusEventHandler != null)
+          {
+            this.ActionClearFocusSignal().Disconnect(_accessibilityManagerActionClearFocusEventCallbackDelegate);
+          }
+
+          _accessibilityManagerActionClearFocusEventHandler -= value;
+        }
+      }
+    }
+
+    // Callback for AccessibilityManager ActionClearFocusSignal
+    private bool OnActionClearFocus(IntPtr data)
+    {
+      ActionClearFocusEventArgs e = new ActionClearFocusEventArgs();
+
+      // Populate all members of "e" (ActionClearFocusEventArgs) with real data
+      e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
+
+      if (_accessibilityManagerActionClearFocusEventHandler != null)
+      {
+        //here we send all data to user event handlers
+        return _accessibilityManagerActionClearFocusEventHandler(this, e);
+      }
+      return false;
+    }
+
+    public event ActionBackEventHandler ActionBack
+    {
+      add
+      {
+        lock(this)
+        {
+          // Restricted to only one listener
+          if (_accessibilityManagerActionBackEventHandler == null)
+          {
+            _accessibilityManagerActionBackEventHandler += value;
+
+            _accessibilityManagerActionBackEventCallbackDelegate = new ActionBackEventCallbackDelegate(OnActionBack);
+            this.ActionBackSignal().Connect(_accessibilityManagerActionBackEventCallbackDelegate);
+          }
+        }
+      }
+
+      remove
+      {
+        lock(this)
+        {
+          if (_accessibilityManagerActionBackEventHandler != null)
+          {
+            this.ActionBackSignal().Disconnect(_accessibilityManagerActionBackEventCallbackDelegate);
+          }
+
+          _accessibilityManagerActionBackEventHandler -= value;
+        }
+      }
+    }
+
+    // Callback for AccessibilityManager ActionBackSignal
+    private bool OnActionBack(IntPtr data)
+    {
+      ActionBackEventArgs e = new ActionBackEventArgs();
+
+      // Populate all members of "e" (ActionBackEventArgs) with real data
+      e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
+
+      if (_accessibilityManagerActionBackEventHandler != null)
+      {
+        //here we send all data to user event handlers
+        return _accessibilityManagerActionBackEventHandler(this, e);
+      }
+      return false;
+    }
+
+    public event ActionScrollUpEventHandler ActionScrollUp
+    {
+      add
+      {
+        lock(this)
+        {
+          // Restricted to only one listener
+          if (_accessibilityManagerActionScrollUpEventHandler == null)
+          {
+            _accessibilityManagerActionScrollUpEventHandler += value;
+
+            _accessibilityManagerActionScrollUpEventCallbackDelegate = new ActionScrollUpEventCallbackDelegate(OnActionScrollUp);
+            this.ActionScrollUpSignal().Connect(_accessibilityManagerActionScrollUpEventCallbackDelegate);
+          }
+        }
+      }
+
+      remove
+      {
+        lock(this)
+        {
+          if (_accessibilityManagerActionScrollUpEventHandler != null)
+          {
+            this.ActionScrollUpSignal().Disconnect(_accessibilityManagerActionScrollUpEventCallbackDelegate);
+          }
+
+          _accessibilityManagerActionScrollUpEventHandler -= value;
+        }
+      }
+    }
+
+    // Callback for AccessibilityManager ActionScrollUpSignal
+    private bool OnActionScrollUp(IntPtr data)
+    {
+      ActionScrollUpEventArgs e = new ActionScrollUpEventArgs();
+
+      // Populate all members of "e" (ActionScrollUpEventArgs) with real data
+      e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
+
+      if (_accessibilityManagerActionScrollUpEventHandler != null)
+      {
+        //here we send all data to user event handlers
+        return _accessibilityManagerActionScrollUpEventHandler(this, e);
+      }
+      return false;
+    }
+
+    public event ActionScrollDownEventHandler ActionScrollDown
+    {
+      add
+      {
+        lock(this)
+        {
+          // Restricted to only one listener
+          if (_accessibilityManagerActionScrollDownEventHandler == null)
+          {
+            _accessibilityManagerActionScrollDownEventHandler += value;
+
+            _accessibilityManagerActionScrollDownEventCallbackDelegate = new ActionScrollDownEventCallbackDelegate(OnActionScrollDown);
+            this.ActionScrollDownSignal().Connect(_accessibilityManagerActionScrollDownEventCallbackDelegate);
+          }
+        }
+      }
+
+      remove
+      {
+        lock(this)
+        {
+          if (_accessibilityManagerActionScrollDownEventHandler != null)
+          {
+            this.ActionScrollDownSignal().Disconnect(_accessibilityManagerActionScrollDownEventCallbackDelegate);
+          }
+
+          _accessibilityManagerActionScrollDownEventHandler -= value;
+        }
+      }
+    }
+
+    // Callback for AccessibilityManager ActionScrollDownSignal
+    private bool OnActionScrollDown(IntPtr data)
+    {
+      ActionScrollDownEventArgs e = new ActionScrollDownEventArgs();
+
+      // Populate all members of "e" (ActionScrollDownEventArgs) with real data
+      e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
+
+      if (_accessibilityManagerActionScrollDownEventHandler != null)
+      {
+        //here we send all data to user event handlers
+        return _accessibilityManagerActionScrollDownEventHandler(this, e);
+      }
+      return false;
+    }
+
+
+    public event ActionPageLeftEventHandler ActionPageLeft
+    {
+      add
+      {
+        lock(this)
+        {
+          // Restricted to only one listener
+          if (_accessibilityManagerActionPageLeftEventHandler == null)
+          {
+            _accessibilityManagerActionPageLeftEventHandler += value;
+
+            _accessibilityManagerActionPageLeftEventCallbackDelegate = new ActionPageLeftEventCallbackDelegate(OnActionPageLeft);
+            this.ActionPageLeftSignal().Connect(_accessibilityManagerActionPageLeftEventCallbackDelegate);
+          }
+        }
+      }
+
+      remove
+      {
+        lock(this)
+        {
+          if (_accessibilityManagerActionPageLeftEventHandler != null)
+          {
+            this.ActionPageLeftSignal().Disconnect(_accessibilityManagerActionPageLeftEventCallbackDelegate);
+          }
+
+          _accessibilityManagerActionPageLeftEventHandler -= value;
+        }
+      }
+    }
+
+    // Callback for AccessibilityManager ActionPageLeftSignal
+    private bool OnActionPageLeft(IntPtr data)
+    {
+      ActionPageLeftEventArgs e = new ActionPageLeftEventArgs();
+
+      // Populate all members of "e" (ActionPageLeftEventArgs) with real data
+      e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
+
+      if (_accessibilityManagerActionPageLeftEventHandler != null)
+      {
+        //here we send all data to user event handlers
+        return _accessibilityManagerActionPageLeftEventHandler(this, e);
+      }
+      return false;
+    }
+
+    public event ActionPageRightEventHandler ActionPageRight
+    {
+      add
+      {
+        lock(this)
+        {
+          // Restricted to only one listener
+          if (_accessibilityManagerActionPageRightEventHandler == null)
+          {
+            _accessibilityManagerActionPageRightEventHandler += value;
+
+            _accessibilityManagerActionPageRightEventCallbackDelegate = new ActionPageRightEventCallbackDelegate(OnActionPageRight);
+            this.ActionPageRightSignal().Connect(_accessibilityManagerActionPageRightEventCallbackDelegate);
+          }
+        }
+      }
+
+      remove
+      {
+        lock(this)
+        {
+          if (_accessibilityManagerActionPageRightEventHandler != null)
+          {
+            this.ActionPageRightSignal().Disconnect(_accessibilityManagerActionPageRightEventCallbackDelegate);
+          }
+
+          _accessibilityManagerActionPageRightEventHandler -= value;
+        }
+      }
+    }
+
+    // Callback for AccessibilityManager ActionPageRightSignal
+    private bool OnActionPageRight(IntPtr data)
+    {
+      ActionPageRightEventArgs e = new ActionPageRightEventArgs();
+
+      // Populate all members of "e" (ActionPageRightEventArgs) with real data
+      e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
+
+      if (_accessibilityManagerActionPageRightEventHandler != null)
+      {
+        //here we send all data to user event handlers
+        return _accessibilityManagerActionPageRightEventHandler(this, e);
+      }
+      return false;
+    }
+
+    public event ActionPageUpEventHandler ActionPageUp
+    {
+      add
+      {
+        lock(this)
+        {
+          // Restricted to only one listener
+          if (_accessibilityManagerActionPageUpEventHandler == null)
+          {
+            _accessibilityManagerActionPageUpEventHandler += value;
+
+            _accessibilityManagerActionPageUpEventCallbackDelegate = new ActionPageUpEventCallbackDelegate(OnActionPageUp);
+            this.ActionPageUpSignal().Connect(_accessibilityManagerActionPageUpEventCallbackDelegate);
+          }
+        }
+      }
+
+      remove
+      {
+        lock(this)
+        {
+          if (_accessibilityManagerActionPageUpEventHandler != null)
+          {
+            this.ActionPageUpSignal().Disconnect(_accessibilityManagerActionPageUpEventCallbackDelegate);
+          }
+
+          _accessibilityManagerActionPageUpEventHandler -= value;
+        }
+      }
+    }
+
+    // Callback for AccessibilityManager ActionPageUpSignal
+    private bool OnActionPageUp(IntPtr data)
+    {
+      ActionPageUpEventArgs e = new ActionPageUpEventArgs();
+
+      // Populate all members of "e" (ActionPageUpEventArgs) with real data
+      e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
+
+      if (_accessibilityManagerActionPageUpEventHandler != null)
+      {
+        //here we send all data to user event handlers
+        return _accessibilityManagerActionPageUpEventHandler(this, e);
+      }
+      return false;
+    }
+
+
+    public event ActionPageDownEventHandler ActionPageDown
+    {
+      add
+      {
+        lock(this)
+        {
+          // Restricted to only one listener
+          if (_accessibilityManagerActionPageDownEventHandler == null)
+          {
+            _accessibilityManagerActionPageDownEventHandler += value;
+
+            _accessibilityManagerActionPageDownEventCallbackDelegate = new ActionPageDownEventCallbackDelegate(OnActionPageDown);
+            this.ActionPageDownSignal().Connect(_accessibilityManagerActionPageDownEventCallbackDelegate);
+          }
+        }
+      }
+
+      remove
+      {
+        lock(this)
+        {
+          if (_accessibilityManagerActionPageDownEventHandler != null)
+          {
+            this.ActionPageDownSignal().Disconnect(_accessibilityManagerActionPageDownEventCallbackDelegate);
+          }
+
+          _accessibilityManagerActionPageDownEventHandler -= value;
+        }
+      }
+    }
+
+    // Callback for AccessibilityManager ActionPageDownSignal
+    private bool OnActionPageDown(IntPtr data)
+    {
+      ActionPageDownEventArgs e = new ActionPageDownEventArgs();
+
+      // Populate all members of "e" (ActionPageDownEventArgs) with real data
+      e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
+
+      if (_accessibilityManagerActionPageDownEventHandler != null)
+      {
+        //here we send all data to user event handlers
+        return _accessibilityManagerActionPageDownEventHandler(this, e);
+      }
+      return false;
+    }
+
+
+    public event ActionMoveToFirstEventHandler ActionMoveToFirst
+    {
+      add
+      {
+        lock(this)
+        {
+          // Restricted to only one listener
+          if (_accessibilityManagerActionMoveToFirstEventHandler == null)
+          {
+            _accessibilityManagerActionMoveToFirstEventHandler += value;
+
+            _accessibilityManagerActionMoveToFirstEventCallbackDelegate = new ActionMoveToFirstEventCallbackDelegate(OnActionMoveToFirst);
+            this.ActionMoveToFirstSignal().Connect(_accessibilityManagerActionMoveToFirstEventCallbackDelegate);
+          }
+        }
+      }
+
+      remove
+      {
+        lock(this)
+        {
+          if (_accessibilityManagerActionMoveToFirstEventHandler != null)
+          {
+            this.ActionMoveToFirstSignal().Disconnect(_accessibilityManagerActionMoveToFirstEventCallbackDelegate);
+          }
+
+          _accessibilityManagerActionMoveToFirstEventHandler -= value;
+        }
+      }
+    }
+
+    // Callback for AccessibilityManager ActionMoveToFirstSignal
+    private bool OnActionMoveToFirst(IntPtr data)
+    {
+      ActionMoveToFirstEventArgs e = new ActionMoveToFirstEventArgs();
+
+      // Populate all members of "e" (ActionMoveToFirstEventArgs) with real data
+      e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
+
+      if (_accessibilityManagerActionMoveToFirstEventHandler != null)
+      {
+        //here we send all data to user event handlers
+        return _accessibilityManagerActionMoveToFirstEventHandler(this, e);
+      }
+      return false;
+    }
+
+    public event ActionMoveToLastEventHandler ActionMoveToLast
+    {
+      add
+      {
+        lock(this)
+        {
+          // Restricted to only one listener
+          if (_accessibilityManagerActionMoveToLastEventHandler == null)
+          {
+            _accessibilityManagerActionMoveToLastEventHandler += value;
+
+            _accessibilityManagerActionMoveToLastEventCallbackDelegate = new ActionMoveToLastEventCallbackDelegate(OnActionMoveToLast);
+            this.ActionMoveToLastSignal().Connect(_accessibilityManagerActionMoveToLastEventCallbackDelegate);
+          }
+        }
+      }
+
+      remove
+      {
+        lock(this)
+        {
+          if (_accessibilityManagerActionMoveToLastEventHandler != null)
+          {
+            this.ActionMoveToLastSignal().Disconnect(_accessibilityManagerActionMoveToLastEventCallbackDelegate);
+          }
+
+          _accessibilityManagerActionMoveToLastEventHandler -= value;
+        }
+      }
+    }
+
+    // Callback for AccessibilityManager ActionMoveToLastSignal
+    private bool OnActionMoveToLast(IntPtr data)
+    {
+      ActionMoveToLastEventArgs e = new ActionMoveToLastEventArgs();
+
+      // Populate all members of "e" (ActionMoveToLastEventArgs) with real data
+      e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
+
+      if (_accessibilityManagerActionMoveToLastEventHandler != null)
+      {
+        //here we send all data to user event handlers
+        return _accessibilityManagerActionMoveToLastEventHandler(this, e);
+      }
+      return false;
+    }
+
+    public event ActionReadFromTopEventHandler ActionReadFromTop
+    {
+      add
+      {
+        lock(this)
+        {
+          // Restricted to only one listener
+          if (_accessibilityManagerActionReadFromTopEventHandler == null)
+          {
+            _accessibilityManagerActionReadFromTopEventHandler += value;
+
+            _accessibilityManagerActionReadFromTopEventCallbackDelegate = new ActionReadFromTopEventCallbackDelegate(OnActionReadFromTop);
+            this.ActionReadFromTopSignal().Connect(_accessibilityManagerActionReadFromTopEventCallbackDelegate);
+          }
+        }
+      }
+
+      remove
+      {
+        lock(this)
+        {
+          if (_accessibilityManagerActionReadFromTopEventHandler != null)
+          {
+            this.ActionReadFromTopSignal().Disconnect(_accessibilityManagerActionReadFromTopEventCallbackDelegate);
+          }
+
+          _accessibilityManagerActionReadFromTopEventHandler -= value;
+        }
+      }
+    }
+
+    // Callback for AccessibilityManager ActionReadFromTopSignal
+    private bool OnActionReadFromTop(IntPtr data)
+    {
+      ActionReadFromTopEventArgs e = new ActionReadFromTopEventArgs();
+
+      // Populate all members of "e" (ActionReadFromTopEventArgs) with real data
+      e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
+
+      if (_accessibilityManagerActionReadFromTopEventHandler != null)
+      {
+        //here we send all data to user event handlers
+        return _accessibilityManagerActionReadFromTopEventHandler(this, e);
+      }
+      return false;
+    }
+
+    public event ActionReadFromNextEventHandler ActionReadFromNext
+    {
+      add
+      {
+        lock(this)
+        {
+          // Restricted to only one listener
+          if (_accessibilityManagerActionReadFromNextEventHandler == null)
+          {
+            _accessibilityManagerActionReadFromNextEventHandler += value;
+
+            _accessibilityManagerActionReadFromNextEventCallbackDelegate = new ActionReadFromNextEventCallbackDelegate(OnActionReadFromNext);
+            this.ActionReadFromNextSignal().Connect(_accessibilityManagerActionReadFromNextEventCallbackDelegate);
+          }
+        }
+      }
+
+      remove
+      {
+        lock(this)
+        {
+          if (_accessibilityManagerActionReadFromNextEventHandler != null)
+          {
+            this.ActionReadFromNextSignal().Disconnect(_accessibilityManagerActionReadFromNextEventCallbackDelegate);
+          }
+
+          _accessibilityManagerActionReadFromNextEventHandler -= value;
+        }
+      }
+    }
+
+    // Callback for AccessibilityManager ActionReadFromNextSignal
+    private bool OnActionReadFromNext(IntPtr data)
+    {
+      ActionReadFromNextEventArgs e = new ActionReadFromNextEventArgs();
+
+      // Populate all members of "e" (ActionReadFromNextEventArgs) with real data
+      e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
+
+      if (_accessibilityManagerActionReadFromNextEventHandler != null)
+      {
+        //here we send all data to user event handlers
+        return _accessibilityManagerActionReadFromNextEventHandler(this, e);
+      }
+      return false;
+    }
+
+    public event ActionZoomEventHandler ActionZoom
+    {
+      add
+      {
+        lock(this)
+        {
+          // Restricted to only one listener
+          if (_accessibilityManagerActionZoomEventHandler == null)
+          {
+            _accessibilityManagerActionZoomEventHandler += value;
+
+            _accessibilityManagerActionZoomEventCallbackDelegate = new ActionZoomEventCallbackDelegate(OnActionZoom);
+            this.ActionZoomSignal().Connect(_accessibilityManagerActionZoomEventCallbackDelegate);
+          }
+        }
+      }
+
+      remove
+      {
+        lock(this)
+        {
+          if (_accessibilityManagerActionZoomEventHandler != null)
+          {
+            this.ActionZoomSignal().Disconnect(_accessibilityManagerActionZoomEventCallbackDelegate);
+          }
+
+          _accessibilityManagerActionZoomEventHandler -= value;
+        }
+      }
+    }
+
+    // Callback for AccessibilityManager ActionZoomSignal
+    private bool OnActionZoom(IntPtr data)
+    {
+      ActionZoomEventArgs e = new ActionZoomEventArgs();
+
+      // Populate all members of "e" (ActionZoomEventArgs) with real data
+      e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
+
+      if (_accessibilityManagerActionZoomEventHandler != null)
+      {
+        //here we send all data to user event handlers
+        return _accessibilityManagerActionZoomEventHandler(this, e);
+      }
+      return false;
+    }
+
+    public event ActionReadIndicatorInformationEventHandler ActionReadIndicatorInformation
+    {
+      add
+      {
+        lock(this)
+        {
+          // Restricted to only one listener
+          if (_accessibilityManagerActionReadIndicatorInformationEventHandler == null)
+          {
+            _accessibilityManagerActionReadIndicatorInformationEventHandler += value;
+
+            _accessibilityManagerActionReadIndicatorInformationEventCallbackDelegate = new ActionReadIndicatorInformationEventCallbackDelegate(OnActionReadIndicatorInformation);
+            this.ActionReadIndicatorInformationSignal().Connect(_accessibilityManagerActionReadIndicatorInformationEventCallbackDelegate);
+          }
+        }
+      }
+
+      remove
+      {
+        lock(this)
+        {
+          if (_accessibilityManagerActionReadIndicatorInformationEventHandler != null)
+          {
+            this.ActionReadIndicatorInformationSignal().Disconnect(_accessibilityManagerActionReadIndicatorInformationEventCallbackDelegate);
+          }
+
+          _accessibilityManagerActionReadIndicatorInformationEventHandler -= value;
+        }
+      }
+    }
+
+    // Callback for AccessibilityManager ActionReadIndicatorInformationSignal
+    private bool OnActionReadIndicatorInformation(IntPtr data)
+    {
+      ActionReadIndicatorInformationEventArgs e = new ActionReadIndicatorInformationEventArgs();
+
+      // Populate all members of "e" (ActionReadIndicatorInformationEventArgs) with real data
+      e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
+
+      if (_accessibilityManagerActionReadIndicatorInformationEventHandler != null)
+      {
+        //here we send all data to user event handlers
+        return _accessibilityManagerActionReadIndicatorInformationEventHandler(this, e);
+      }
+      return false;
+    }
+
+    public event ActionReadPauseResumeEventHandler ActionReadPauseResume
+    {
+      add
+      {
+        lock(this)
+        {
+          // Restricted to only one listener
+          if (_accessibilityManagerActionReadPauseResumeEventHandler == null)
+          {
+            _accessibilityManagerActionReadPauseResumeEventHandler += value;
+
+            _accessibilityManagerActionReadPauseResumeEventCallbackDelegate = new ActionReadPauseResumeEventCallbackDelegate(OnActionReadPauseResume);
+            this.ActionReadPauseResumeSignal().Connect(_accessibilityManagerActionReadPauseResumeEventCallbackDelegate);
+          }
+        }
+      }
+
+      remove
+      {
+        lock(this)
+        {
+          if (_accessibilityManagerActionReadPauseResumeEventHandler != null)
+          {
+            this.ActionReadPauseResumeSignal().Disconnect(_accessibilityManagerActionReadPauseResumeEventCallbackDelegate);
+          }
+
+          _accessibilityManagerActionReadPauseResumeEventHandler -= value;
+        }
+      }
+    }
+
+    // Callback for AccessibilityManager ActionReadPauseResumeSignal
+    private bool OnActionReadPauseResume(IntPtr data)
+    {
+      ActionReadPauseResumeEventArgs e = new ActionReadPauseResumeEventArgs();
+
+      // Populate all members of "e" (ActionReadPauseResumeEventArgs) with real data
+      e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
+
+      if (_accessibilityManagerActionReadPauseResumeEventHandler != null)
+      {
+        //here we send all data to user event handlers
+        return _accessibilityManagerActionReadPauseResumeEventHandler(this, e);
+      }
+      return false;
+    }
+
+    public event ActionStartStopEventHandler ActionStartStop
+    {
+      add
+      {
+        lock(this)
+        {
+          // Restricted to only one listener
+          if (_accessibilityManagerActionStartStopEventHandler == null)
+          {
+            _accessibilityManagerActionStartStopEventHandler += value;
+
+            _accessibilityManagerActionStartStopEventCallbackDelegate = new ActionStartStopEventCallbackDelegate(OnActionStartStop);
+            this.ActionStartStopSignal().Connect(_accessibilityManagerActionStartStopEventCallbackDelegate);
+          }
+        }
+      }
+
+      remove
+      {
+        lock(this)
+        {
+          if (_accessibilityManagerActionStartStopEventHandler != null)
+          {
+            this.ActionStartStopSignal().Disconnect(_accessibilityManagerActionStartStopEventCallbackDelegate);
+          }
+
+          _accessibilityManagerActionStartStopEventHandler -= value;
+        }
+      }
+    }
+
+    // Callback for AccessibilityManager ActionStartStopSignal
+    private bool OnActionStartStop(IntPtr data)
+    {
+      ActionStartStopEventArgs e = new ActionStartStopEventArgs();
+
+      // Populate all members of "e" (ActionStartStopEventArgs) with real data
+      e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
+
+      if (_accessibilityManagerActionStartStopEventHandler != null)
+      {
+        //here we send all data to user event handlers
+        return _accessibilityManagerActionStartStopEventHandler(this, e);
+      }
+      return false;
+    }
+
+    public event ActionScrollEventHandler ActionScroll
+    {
+      add
+      {
+        lock(this)
+        {
+          // Restricted to only one listener
+          if (_accessibilityManagerActionScrollEventHandler == null)
+          {
+            _accessibilityManagerActionScrollEventHandler += value;
+
+            _accessibilityManagerActionScrollEventCallbackDelegate = new ActionScrollEventCallbackDelegate(OnActionScroll);
+            this.ActionScrollSignal().Connect(_accessibilityManagerActionScrollEventCallbackDelegate);
+          }
+        }
+      }
+
+      remove
+      {
+        lock(this)
+        {
+          if (_accessibilityManagerActionScrollEventHandler != null)
+          {
+            this.ActionScrollSignal().Disconnect(_accessibilityManagerActionScrollEventCallbackDelegate);
+          }
+
+          _accessibilityManagerActionScrollEventHandler -= value;
+        }
+      }
+    }
+
+    // Callback for AccessibilityManager ActionScrollSignal
+    private bool OnActionScroll(IntPtr accessibilityManager, IntPtr touchEvent)
+    {
+      ActionScrollEventArgs e = new ActionScrollEventArgs();
+
+      // Populate all members of "e" (ActionScrollEventArgs) with real data
+      e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(accessibilityManager);
+      e.TouchEvent = TouchEvent.GetTouchEventFromPtr(touchEvent);
+
+      if (_accessibilityManagerActionScrollEventHandler != null)
+      {
+        //here we send all data to user event handlers
+        return _accessibilityManagerActionScrollEventHandler(this, e);
+      }
+      return false;
+    }
+
+    public event FocusChangedEventHandler FocusChanged
+    {
+      add
+      {
+        lock(this)
+        {
+          // Restricted to only one listener
+          if (_accessibilityManagerFocusChangedEventHandler == null)
+          {
+            _accessibilityManagerFocusChangedEventHandler += value;
+
+            _accessibilityManagerFocusChangedEventCallbackDelegate = new FocusChangedEventCallbackDelegate(OnFocusChanged);
+            this.FocusChangedSignal().Connect(_accessibilityManagerFocusChangedEventCallbackDelegate);
+          }
+        }
+      }
+
+      remove
+      {
+        lock(this)
+        {
+          if (_accessibilityManagerFocusChangedEventHandler != null)
+          {
+            this.FocusChangedSignal().Disconnect(_accessibilityManagerFocusChangedEventCallbackDelegate);
+          }
+
+          _accessibilityManagerFocusChangedEventHandler -= value;
+        }
+      }
+    }
+
+    // Callback for AccessibilityManager FocusChangedSignal
+    private void OnFocusChanged(IntPtr actor1, IntPtr actor2)
+    {
+      FocusChangedEventArgs e = new FocusChangedEventArgs();
+
+      // Populate all members of "e" (FocusChangedEventArgs) with real data
+      e.ActorCurrent = Actor.GetActorFromPtr(actor1);
+      e.ActorNext = Actor.GetActorFromPtr(actor2);
+
+      if (_accessibilityManagerFocusChangedEventHandler != null)
+      {
+        //here we send all data to user event handlers
+        _accessibilityManagerFocusChangedEventHandler(this, e);
+      }
+    }
+
+    public event FocusedActorActivatedEventHandler FocusedActorActivated
+    {
+      add
+      {
+        lock(this)
+        {
+          // Restricted to only one listener
+          if (_accessibilityManagerFocusedActorActivatedEventHandler == null)
+          {
+            _accessibilityManagerFocusedActorActivatedEventHandler += value;
+
+            _accessibilityManagerFocusedActorActivatedEventCallbackDelegate = new FocusedActorActivatedEventCallbackDelegate(OnFocusedActorActivated);
+            this.FocusedActorActivatedSignal().Connect(_accessibilityManagerFocusedActorActivatedEventCallbackDelegate);
+          }
+        }
+      }
+
+      remove
+      {
+        lock(this)
+        {
+          if (_accessibilityManagerFocusedActorActivatedEventHandler != null)
+          {
+            this.FocusedActorActivatedSignal().Disconnect(_accessibilityManagerFocusedActorActivatedEventCallbackDelegate);
+          }
+
+          _accessibilityManagerFocusedActorActivatedEventHandler -= value;
+        }
+      }
+    }
+
+    // Callback for AccessibilityManager FocusedActorActivatedSignal
+    private void OnFocusedActorActivated(IntPtr actor)
+    {
+      FocusedActorActivatedEventArgs e = new FocusedActorActivatedEventArgs();
+
+      // Populate all members of "e" (FocusedActorActivatedEventArgs) with real data
+      e.Actor = Actor.GetActorFromPtr(actor);
+
+      if (_accessibilityManagerFocusedActorActivatedEventHandler != null)
+      {
+        //here we send all data to user event handlers
+        _accessibilityManagerFocusedActorActivatedEventHandler(this, e);
+      }
+    }
+
+
+    public event FocusOvershotEventHandler FocusOvershot
+    {
+      add
+      {
+        lock(this)
+        {
+          // Restricted to only one listener
+          if (_accessibilityManagerFocusOvershotEventHandler == null)
+          {
+            _accessibilityManagerFocusOvershotEventHandler += value;
+
+            _accessibilityManagerFocusOvershotEventCallbackDelegate = new FocusOvershotEventCallbackDelegate(OnFocusOvershot);
+            this.FocusOvershotSignal().Connect(_accessibilityManagerFocusOvershotEventCallbackDelegate);
+          }
+        }
+      }
+
+      remove
+      {
+        lock(this)
+        {
+          if (_accessibilityManagerFocusOvershotEventHandler != null)
+          {
+            this.FocusOvershotSignal().Disconnect(_accessibilityManagerFocusOvershotEventCallbackDelegate);
+          }
+
+          _accessibilityManagerFocusOvershotEventHandler -= value;
+        }
+      }
+    }
+
+    // Callback for AccessibilityManager FocusOvershotSignal
+    private void OnFocusOvershot(IntPtr currentFocusedActor, AccessibilityManager.FocusOvershotDirection direction)
+    {
+      FocusOvershotEventArgs e = new FocusOvershotEventArgs();
+
+      // Populate all members of "e" (FocusOvershotEventArgs) with real data
+      e.CurrentFocusedActor = Actor.GetActorFromPtr(currentFocusedActor);
+      e.FocusOvershotDirection = direction;
+
+      if (_accessibilityManagerFocusOvershotEventHandler != null)
+      {
+        //here we send all data to user event handlers
+        _accessibilityManagerFocusOvershotEventHandler(this, e);
+      }
+    }
+
+
+    public static ClassName Get ## ClassName ## FromPtr(global::System.IntPtr cPtr) {
+      ClassName ret = new ClassName(cPtr, false);
+      if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+      return ret;
+    }
+
+    %}
+    %enddef
+
+%define DALI_ACCESSIBILITY_EVENTHANDLER_PARAM( NameSpace, ClassName)
+  ACCESSIBILITY_EVENTHANDLER_TYPEMAP_EVENTARG( NameSpace, ClassName);
+  ACCESSIBILITY_EVENTHANDLER_TYPEMAP_HELPER( NameSpace, ClassName);
+  %enddef
+
+  namespace Dali
+{
+  DALI_ACCESSIBILITY_EVENTHANDLER_PARAM( Dali::Toolkit, AccessibilityManager);
+}
+
+
diff --git a/plugins/dali-swig/SWIG/events/actor-event.i b/plugins/dali-swig/SWIG/events/actor-event.i
new file mode 100644 (file)
index 0000000..e325613
--- /dev/null
@@ -0,0 +1,620 @@
+/*
+ * Copyright (c) 2016 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.
+ *
+ */
+
+%define ACTOR_EVENTHANDLER_TYPEMAP_EVENTARG(NameSpace, ClassName)
+%typemap(csimports) NameSpace::ClassName %{
+    using System;
+    using System.Runtime.InteropServices;
+%}
+
+%enddef
+
+%define ACTOR_EVENTHANDLER_TYPEMAP_HELPER(NameSpace, ClassName)
+  %typemap(cscode) NameSpace::ClassName %{
+
+
+    /**
+      * @brief Event arguments that passed via Touch signal
+      *
+      */
+    public class TouchEventArgs : EventArgs
+    {
+       private Actor _actor;
+       private TouchData _touchData;
+
+      /**
+        * @brief Actor - is the actor that is being touched
+        *
+        */
+      public Actor Actor
+      {
+        get
+        {
+          return _actor;
+        }
+        set
+        {
+          _actor = value;
+        }
+      }
+
+      /**
+        * @brief TouchData - contains the information of touch points
+        *
+        */
+      public TouchData TouchData
+      {
+        get
+        {
+          return _touchData;
+        }
+        set
+        {
+          _touchData = value;
+        }
+      }
+    }
+
+    /**
+      * @brief Event arguments that passed via Hover signal
+      *
+      */
+    public class HoverEventArgs : EventArgs
+    {
+    private Actor _actor;
+    private HoverEvent _hoverEvent;
+
+      /**
+        * @brief Actor - is the actor that is being hovered
+        *
+        */
+      public Actor Actor
+      {
+        get
+        {
+          return _actor;
+        }
+        set
+        {
+          _actor = value;
+        }
+      }
+
+      /**
+        * @brief HoverEvent - contains touch points that represent the points
+        * that are currently being hovered or the points where a hover has stopped
+        *
+        */
+      public HoverEvent HoverEvent
+      {
+        get
+        {
+          return _hoverEvent;
+        }
+        set
+        {
+          _hoverEvent = value;
+        }
+      }
+    }
+
+    /**
+      * @brief Event arguments that passed via Wheel signal
+      *
+      */
+    public class WheelEventArgs : EventArgs
+    {
+    private Actor _actor;
+    private WheelEvent _wheelEvent;
+
+      /**
+        * @brief Actor - is the actor that is being wheeled
+        *
+        */
+      public Actor Actor
+      {
+        get
+        {
+          return _actor;
+        }
+        set
+        {
+          _actor = value;
+        }
+      }
+
+      /**
+        * @brief WheelEvent - store a wheel rolling type : MOUSE_WHEEL or CUSTOM_WHEEL
+        *
+        */
+      public WheelEvent WheelEvent
+      {
+        get
+        {
+          return _wheelEvent;
+        }
+        set
+        {
+          _wheelEvent = value;
+        }
+      }
+    }
+
+    /**
+      * @brief Event arguments that passed via OnStage signal
+      *
+      */
+    public class OnStageEventArgs : EventArgs
+    {
+    private Actor _actor;
+
+      /**
+        * @brief Actor - is the actor that is being connected to the stage
+        *
+        */
+      public Actor Actor
+      {
+        get
+        {
+          return _actor;
+        }
+        set
+        {
+          _actor = value;
+        }
+      }
+    }
+
+    /**
+      * @brief Event arguments that passed via OffStage signal
+      *
+      */
+    public class OffStageEventArgs : EventArgs
+    {
+    private Actor _actor;
+
+      /**
+        * @brief Actor - is the actor that is being disconnected from the stage
+        *
+        */
+      public Actor Actor
+      {
+        get
+        {
+          return _actor;
+        }
+        set
+        {
+          _actor = value;
+        }
+      }
+    }
+
+    /**
+      * @brief Event arguments that passed via OnRelayout signal
+      *
+      */
+    public class OnRelayoutEventArgs : EventArgs
+    {
+      private Actor _actor;
+
+      /**
+        * @brief Actor - is the actor that is being resized upon relayout
+        *
+        */
+      public Actor Actor
+      {
+        get
+        {
+          return _actor;
+        }
+        set
+        {
+          _actor = value;
+        }
+      }
+    }
+
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool TouchEventHandler(object source, TouchEventArgs e);
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool HoverEventHandler(object source, HoverEventArgs e);
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool WheelEventHandler(object source, WheelEventArgs e);
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate void OnStageEventHandler(object source, OnStageEventArgs e);
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate void OffStageEventHandler(object source, OffStageEventArgs e);
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate void OnRelayoutEventHandler(object source, OnRelayoutEventArgs e);
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    private delegate bool TouchCallbackDelegate(IntPtr actor, IntPtr touchData);
+    private TouchEventHandler _actorTouchDataEventHandler;
+    private TouchCallbackDelegate _actorTouchDataCallbackDelegate;
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    private delegate bool HoverEventCallbackDelegate(IntPtr actor, IntPtr hoverEvent);
+    private HoverEventHandler _actorHoverEventHandler;
+    private HoverEventCallbackDelegate _actorHoverEventCallbackDelegate;
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    private delegate bool WheelEventCallbackDelegate(IntPtr actor, IntPtr wheelEvent);
+    private WheelEventHandler _actorWheelEventHandler;
+    private WheelEventCallbackDelegate _actorWheelEventCallbackDelegate;
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    private delegate void OnStageEventCallbackDelegate(IntPtr actor);
+    private OnStageEventHandler _actorOnStageEventHandler;
+    private OnStageEventCallbackDelegate _actorOnStageEventCallbackDelegate;
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    private delegate void OffStageEventCallbackDelegate(IntPtr actor);
+    private OffStageEventHandler _actorOffStageEventHandler;
+    private OffStageEventCallbackDelegate _actorOffStageEventCallbackDelegate;
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    private delegate void OnRelayoutEventCallbackDelegate(IntPtr actor);
+    private OnRelayoutEventHandler _actorOnRelayoutEventHandler;
+    private OnRelayoutEventCallbackDelegate _actorOnRelayoutEventCallbackDelegate;
+
+    /**
+      * @brief Event for Touched signal which can be used to subscribe/unsubscribe the event handler
+      * (in the type of TouchEventHandler) provided by the user.
+      * Touched signal is emitted when touch input is received.
+      */
+    public event TouchEventHandler Touched
+    {
+      add
+      {
+        lock(this)
+        {
+          // Restricted to only one listener
+          if (_actorTouchDataEventHandler == null)
+          {
+            _actorTouchDataEventHandler += value;
+
+            _actorTouchDataCallbackDelegate = new TouchCallbackDelegate(OnTouch);
+            this.TouchSignal().Connect(_actorTouchDataCallbackDelegate);
+          }
+        }
+      }
+
+      remove
+      {
+        lock(this)
+        {
+          if (_actorTouchDataEventHandler != null)
+          {
+            this.TouchSignal().Disconnect(_actorTouchDataCallbackDelegate);
+          }
+
+          _actorTouchDataEventHandler -= value;
+        }
+      }
+    }
+
+    // Callback for Actor TouchSignal
+    private bool OnTouch(IntPtr actor, IntPtr touchData)
+    {
+      TouchEventArgs e = new TouchEventArgs();
+
+      // Populate all members of "e" (TouchEventArgs) with real data
+      e.Actor = Actor.GetActorFromPtr(actor);
+      e.TouchData = Dali.TouchData.GetTouchDataFromPtr(touchData);
+
+      if (_actorTouchDataEventHandler != null)
+      {
+        //here we send all data to user event handlers
+        return _actorTouchDataEventHandler(this, e);
+      }
+
+      return false;
+    }
+
+    /**
+      * @brief Event for Hovered signal which can be used to subscribe/unsubscribe the event handler
+      * (in the type of HoverEventHandler) provided by the user.
+      * Hovered signal is emitted when hover input is received.
+      */
+    public event HoverEventHandler Hovered
+    {
+      add
+      {
+        lock(this)
+        {
+          // Restricted to only one listener
+          if (_actorHoverEventHandler == null)
+          {
+            _actorHoverEventHandler += value;
+
+            _actorHoverEventCallbackDelegate = new HoverEventCallbackDelegate(OnHoverEvent);
+            this.HoveredSignal().Connect(_actorHoverEventCallbackDelegate);
+          }
+        }
+      }
+
+      remove
+      {
+        lock(this)
+        {
+          if (_actorHoverEventHandler != null)
+          {
+            this.HoveredSignal().Disconnect(_actorHoverEventCallbackDelegate);
+          }
+
+          _actorHoverEventHandler -= value;
+        }
+      }
+    }
+
+    // Callback for Actor Hover signal
+    private bool OnHoverEvent(IntPtr actor, IntPtr hoverEvent)
+    {
+      HoverEventArgs e = new HoverEventArgs();
+
+      // Populate all members of "e" (HoverEventArgs) with real data
+      e.Actor = Actor.GetActorFromPtr(actor);
+      e.HoverEvent = Dali.HoverEvent.GetHoverEventFromPtr(hoverEvent);
+
+      if (_actorHoverEventHandler != null)
+      {
+        //here we send all data to user event handlers
+        return _actorHoverEventHandler(this, e);
+      }
+
+      return false;
+    }
+
+    /**
+      * @brief Event for WheelMoved signal which can be used to subscribe/unsubscribe the event handler
+      * (in the type of WheelEventHandler) provided by the user.
+      * WheelMoved signal is emitted when wheel event is received.
+      */
+    public event WheelEventHandler WheelMoved
+    {
+      add
+      {
+        lock(this)
+        {
+          // Restricted to only one listener
+          if (_actorWheelEventHandler == null)
+          {
+            _actorWheelEventHandler += value;
+
+            _actorWheelEventCallbackDelegate = new WheelEventCallbackDelegate(OnWheelEvent);
+            this.WheelEventSignal().Connect(_actorWheelEventCallbackDelegate);
+          }
+        }
+      }
+
+      remove
+      {
+        lock(this)
+        {
+          if (_actorWheelEventHandler != null)
+          {
+            this.WheelEventSignal().Disconnect(_actorWheelEventCallbackDelegate);
+          }
+
+          _actorWheelEventHandler -= value;
+        }
+      }
+    }
+
+    // Callback for Actor Wheel signal
+    private bool OnWheelEvent(IntPtr actor, IntPtr wheelEvent)
+    {
+      WheelEventArgs e = new WheelEventArgs();
+
+      // Populate all members of "e" (WheelEventArgs) with real data
+      e.Actor = Actor.GetActorFromPtr(actor);
+      e.WheelEvent = Dali.WheelEvent.GetWheelEventFromPtr(wheelEvent);
+
+      if (_actorWheelEventHandler != null)
+      {
+        //here we send all data to user event handlers
+        return _actorWheelEventHandler(this, e);
+      }
+
+      return false;
+    }
+
+    /**
+      * @brief Event for OnStage signal which can be used to subscribe/unsubscribe the event handler
+      * (in the type of OnStageEventHandler) provided by the user.
+      * OnStage signal is emitted after the actor has been connected to the stage.
+      */
+    public event OnStageEventHandler OnStageEvent
+    {
+      add
+      {
+        lock(this)
+        {
+          // Restricted to only one listener
+          if (_actorOnStageEventHandler == null)
+          {
+            _actorOnStageEventHandler += value;
+
+            _actorOnStageEventCallbackDelegate = new OnStageEventCallbackDelegate(OnStage);
+            this.OnStageSignal().Connect(_actorOnStageEventCallbackDelegate);
+          }
+        }
+      }
+
+      remove
+      {
+        lock(this)
+        {
+          if (_actorOnStageEventHandler != null)
+          {
+            this.OnStageSignal().Disconnect(_actorOnStageEventCallbackDelegate);
+          }
+
+          _actorOnStageEventHandler -= value;
+        }
+      }
+    }
+
+    // Callback for Actor OnStage signal
+    private void OnStage(IntPtr data)
+    {
+      OnStageEventArgs e = new OnStageEventArgs();
+
+      // Populate all members of "e" (OnStageEventArgs) with real data
+      e.Actor = Actor.GetActorFromPtr(data);
+
+      if (_actorOnStageEventHandler != null)
+      {
+        //here we send all data to user event handlers
+        _actorOnStageEventHandler(this, e);
+      }
+    }
+
+    /**
+      * @brief Event for OffStage signal which can be used to subscribe/unsubscribe the event handler
+      * (in the type of OffStageEventHandler) provided by the user.
+      * OffStage signal is emitted after the actor has been disconnected from the stage.
+      */
+    public event OffStageEventHandler OffStageEvent
+    {
+      add
+      {
+        lock(this)
+        {
+          // Restricted to only one listener
+          if (_actorOffStageEventHandler == null)
+          {
+            _actorOffStageEventHandler += value;
+
+            _actorOffStageEventCallbackDelegate = new OffStageEventCallbackDelegate(OffStage);
+            this.OnStageSignal().Connect(_actorOffStageEventCallbackDelegate);
+          }
+        }
+      }
+
+      remove
+      {
+        lock(this)
+        {
+          if (_actorOffStageEventHandler != null)
+          {
+            this.OnStageSignal().Disconnect(_actorOffStageEventCallbackDelegate);
+          }
+
+          _actorOffStageEventHandler -= value;
+        }
+      }
+    }
+
+    // Callback for Actor OffStage signal
+    private void OffStage(IntPtr data)
+    {
+      OffStageEventArgs e = new OffStageEventArgs();
+
+      // Populate all members of "e" (OffStageEventArgs) with real data
+      e.Actor = Actor.GetActorFromPtr(data);
+
+      if (_actorOffStageEventHandler != null)
+      {
+        //here we send all data to user event handlers
+        _actorOffStageEventHandler(this, e);
+      }
+    }
+
+    /**
+      * @brief Event for OnRelayout signal which can be used to subscribe/unsubscribe the event handler
+      * (in the type of OnRelayoutEventHandler) provided by the user.
+      * OnRelayout signal is emitted after the size has been set on the actor during relayout.
+      */
+    public event OnRelayoutEventHandler OnRelayoutEvent
+    {
+      add
+      {
+        lock(this)
+        {
+          // Restricted to only one listener
+          if (_actorOnRelayoutEventHandler == null)
+          {
+            _actorOnRelayoutEventHandler += value;
+
+            _actorOnRelayoutEventCallbackDelegate = new OnRelayoutEventCallbackDelegate(OnRelayout);
+            this.OnRelayoutSignal().Connect(_actorOnRelayoutEventCallbackDelegate);
+          }
+        }
+      }
+
+      remove
+      {
+        lock(this)
+        {
+          if (_actorOnRelayoutEventHandler != null)
+          {
+            this.OnRelayoutSignal().Disconnect(_actorOnRelayoutEventCallbackDelegate);
+          }
+
+          _actorOnRelayoutEventHandler -= value;
+        }
+      }
+    }
+
+    // Callback for Actor OnRelayout signal
+    private void OnRelayout(IntPtr data)
+    {
+      OnRelayoutEventArgs e = new OnRelayoutEventArgs();
+
+      // Populate all members of "e" (OnRelayoutEventArgs) with real data
+      e.Actor = Actor.GetActorFromPtr(data);
+
+      if (_actorOnRelayoutEventHandler != null)
+      {
+        //here we send all data to user event handlers
+        _actorOnRelayoutEventHandler(this, e);
+      }
+    }
+
+    public static ClassName Get ## ClassName ## FromPtr(global::System.IntPtr cPtr) {
+      ClassName ret = new ClassName(cPtr, false);
+      if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+      return ret;
+    }
+
+    public IntPtr GetPtrfrom ## ClassName ()
+    {
+       return (IntPtr)swigCPtr;
+    }
+    %}
+
+    %enddef
+
+%define DALI_ACTOR_EVENTHANDLER_PARAM( NameSpace, ClassName)
+
+  ACTOR_EVENTHANDLER_TYPEMAP_EVENTARG( NameSpace, ClassName);
+  ACTOR_EVENTHANDLER_TYPEMAP_HELPER( NameSpace, ClassName);
+
+  %enddef
+
+  namespace Dali
+{
+  DALI_ACTOR_EVENTHANDLER_PARAM( Dali, Actor);
+}
diff --git a/plugins/dali-swig/SWIG/events/animation-event.i b/plugins/dali-swig/SWIG/events/animation-event.i
new file mode 100644 (file)
index 0000000..8639532
--- /dev/null
@@ -0,0 +1,134 @@
+/*
+ * Copyright (c) 2016 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.
+ *
+ */
+
+%define Animation_EVENTHANDLER_TYPEMAP_EVENTARG(NameSpace, ClassName)
+  %typemap(csimports) NameSpace::ClassName %{
+    using System;
+    using System.Runtime.InteropServices;
+
+    %}
+    %enddef
+
+%define Animation_EVENTHANDLER_TYPEMAP_HELPER(NameSpace, ClassName)
+  %typemap(cscode) NameSpace::ClassName %{
+
+
+    /**
+      * @brief Event arguments that passed via Finished signal
+      *
+      */
+    public class FinishedEventArgs : EventArgs
+    {
+      private Animation _animation;
+
+      /**
+        * @brief Animation - is the Animation which has finished with the animation.
+        *
+        */
+      public Animation Animation
+      {
+        get
+        {
+          return _animation;
+        }
+        set
+        {
+          _animation = value;
+        }
+      }
+    }
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate void FinishedEventHandler(object source, FinishedEventArgs e);
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    private delegate void FinishedEventCallbackDelegate(IntPtr Animation);
+    private FinishedEventHandler _animationFinishedEventHandler;
+    private FinishedEventCallbackDelegate _animationFinishedEventCallbackDelegate;
+
+    /**
+      * @brief Event for Finished signal which can be used to subscribe/unsubscribe the event handler
+      * (in the type of FinishedEventHandler) provided by the user.
+      * Finished signal is emitted when an Animation's animations have finished.
+      */
+    public event FinishedEventHandler Finished
+    {
+      add
+      {
+        lock(this)
+        {
+          // Restricted to only one listener
+          if (_animationFinishedEventHandler == null)
+          {
+            _animationFinishedEventHandler += value;
+
+            _animationFinishedEventCallbackDelegate = new FinishedEventCallbackDelegate(OnFinished);
+            this.FinishedSignal().Connect(_animationFinishedEventCallbackDelegate);
+          }
+        }
+      }
+
+      remove
+      {
+        lock(this)
+        {
+          if (_animationFinishedEventHandler != null)
+          {
+            this.FinishedSignal().Disconnect(_animationFinishedEventCallbackDelegate);
+          }
+
+          _animationFinishedEventHandler -= value;
+        }
+      }
+    }
+
+    // Callback for Animation FinishedSignal
+    private void OnFinished(IntPtr data)
+    {
+      FinishedEventArgs e = new FinishedEventArgs();
+
+      // Populate all members of "e" (FinishedEventArgs) with real data
+      e.Animation = Animation.GetAnimationFromPtr(data);
+
+      if (_animationFinishedEventHandler != null)
+      {
+        //here we send all data to user event handlers
+        _animationFinishedEventHandler(this, e);
+      }
+    }
+
+
+    public static ClassName Get ## ClassName ## FromPtr(global::System.IntPtr cPtr) {
+      ClassName ret = new ClassName(cPtr, false);
+      if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+      return ret;
+    }
+
+    %}
+
+    %enddef
+
+
+%define DALI_animation_EVENTHANDLER_PARAM( NameSpace, ClassName)
+  Animation_EVENTHANDLER_TYPEMAP_EVENTARG( NameSpace, ClassName);
+  Animation_EVENTHANDLER_TYPEMAP_HELPER( NameSpace, ClassName);
+  %enddef
+
+  namespace Dali
+{
+  DALI_animation_EVENTHANDLER_PARAM( Dali, Animation);
+}
diff --git a/plugins/dali-swig/SWIG/events/application-event.i b/plugins/dali-swig/SWIG/events/application-event.i
new file mode 100644 (file)
index 0000000..af9ebdf
--- /dev/null
@@ -0,0 +1,1059 @@
+/*
+ * Copyright (c) 2016 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.
+ *
+ */
+
+%define APPLICATION_EVENTHANDLER_TYPEMAP_EVENTARG(NameSpace, ClassName)
+  %typemap(csimports) NameSpace::ClassName %{
+    using System;
+    using System.Runtime.InteropServices;
+
+    /**
+      * @brief Event arguments that passed via AUIApplicationInit signal
+      *
+      */
+    public class AUIApplicationInitEventArgs : EventArgs
+    {
+    private Application _application;
+
+      /**
+        * @brief Application - is the application that is being initialized
+        *
+        */
+    public Application Application
+      {
+        get
+        {
+          return _application;
+        }
+        set
+        {
+          _application = value;
+        }
+      }
+    }
+
+    /**
+      * @brief Event arguments that passed via AUIApplicationTerminate signal
+      *
+      */
+    public class AUIApplicationTerminateEventArgs : EventArgs
+    {
+    private Application _application;
+      /**
+        * @brief Application - is the application that is being Terminated
+        *
+        */
+    public Application Application
+      {
+        get
+        {
+          return _application;
+        }
+        set
+        {
+          _application = value;
+        }
+      }
+    }
+
+    /**
+      * @brief Event arguments that passed via AUIApplicationPause signal
+      *
+      */
+    public class AUIApplicationPauseEventArgs : EventArgs
+    {
+    private Application _application;
+      /**
+        * @brief Application - is the application that is being Paused
+        *
+        */
+    public Application Application
+      {
+        get
+        {
+          return _application;
+        }
+        set
+        {
+          _application = value;
+        }
+      }
+    }
+
+    /**
+      * @brief Event arguments that passed via AUIApplicationResume signal
+      *
+      */
+    public class AUIApplicationResumeEventArgs : EventArgs
+    {
+    private Application _application;
+      /**
+        * @brief Application - is the application that is being Resumed
+        *
+        */
+    public Application Application
+      {
+        get
+        {
+          return _application;
+        }
+        set
+        {
+          _application = value;
+        }
+      }
+    }
+
+    /**
+      * @brief Event arguments that passed via AUIApplicationReset signal
+      *
+      */
+    public class AUIApplicationResetEventArgs : EventArgs
+    {
+    private Application _application;
+      /**
+        * @brief Application - is the application that is being Reset
+        *
+        */
+    public Application Application
+      {
+        get
+        {
+          return _application;
+        }
+        set
+        {
+          _application = value;
+        }
+      }
+    }
+
+    /**
+      * @brief Event arguments that passed via AUIApplicationResize signal
+      *
+      */
+    public class AUIApplicationResizeEventArgs : EventArgs
+    {
+    private Application _application;
+      /**
+        * @brief Application - is the application that is being Resized
+        *
+        */
+    public Application Application
+      {
+        get
+        {
+          return _application;
+        }
+        set
+        {
+          _application = value;
+        }
+      }
+    }
+
+    /**
+      * @brief Event arguments that passed via AUIApplicationLanguageChanged signal
+      *
+      */
+    public class AUIApplicationLanguageChangedEventArgs : EventArgs
+    {
+    private Application _application;
+      /**
+        * @brief Application - is the application that is being affected with Device's language change
+        *
+        */
+    public Application Application
+      {
+        get
+        {
+          return _application;
+        }
+        set
+        {
+          _application = value;
+        }
+      }
+    }
+
+    /**
+      * @brief Event arguments that passed via AUIApplicationRegionChanged signal
+      *
+      */
+    public class AUIApplicationRegionChangedEventArgs : EventArgs
+    {
+    private Application _application;
+      /**
+        * @brief Application - is the application that is being affected with Device's region change
+        *
+        */
+    public Application Application
+      {
+        get
+        {
+          return _application;
+        }
+        set
+        {
+          _application = value;
+        }
+      }
+    }
+
+    /**
+      * @brief Event arguments that passed via AUIApplicationBatteryLow signal
+      *
+      */
+    public class AUIApplicationBatteryLowEventArgs : EventArgs
+    {
+    private Application _application;
+      /**
+        * @brief Application - is the application that is being affected when the battery level of the device is low
+        *
+        */
+    public Application Application
+      {
+        get
+        {
+          return _application;
+        }
+        set
+        {
+          _application = value;
+        }
+      }
+    }
+
+    /**
+      * @brief Event arguments that passed via AUIApplicationMemoryLow signal
+      *
+      */
+    public class AUIApplicationMemoryLowEventArgs : EventArgs
+    {
+    private Application _application;
+      /**
+        * @brief Application - is the application that is being affected when the memory level of the device is low
+        *
+        */
+    public Application Application
+      {
+        get
+        {
+          return _application;
+        }
+        set
+        {
+          _application = value;
+        }
+      }
+    }
+
+    /**
+      * @brief Event arguments that passed via AUIApplicationAppControl         signal
+      *
+      */
+    public class AUIApplicationAppControlEventArgs : EventArgs
+    {
+    private Application _application;
+    private IntPtr _voidp;
+      /**
+        * @brief Application - is the application that is receiving the launch request from another application
+        *
+        */
+    public Application Application
+      {
+        get
+        {
+          return _application;
+        }
+        set
+        {
+          _application = value;
+        }
+      }
+      /**
+        * @brief VoidP - contains the information about why the application is launched
+        *
+        */
+    public IntPtr VoidP
+      {
+        get
+        {
+          return _voidp;
+        }
+        set
+        {
+          _voidp = value;
+        }
+      }
+    }
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate void AUIApplicationInitEventHandler(object source, AUIApplicationInitEventArgs e);
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate void AUIApplicationTerminateEventHandler(object source, AUIApplicationTerminateEventArgs e);
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate void AUIApplicationPauseEventHandler(object source, AUIApplicationPauseEventArgs e);
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate void AUIApplicationResumeEventHandler(object source, AUIApplicationResumeEventArgs e);
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate void AUIApplicationResetEventHandler(object source, AUIApplicationResetEventArgs e);
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate void AUIApplicationResizeEventHandler(object source, AUIApplicationResizeEventArgs e);
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate void AUIApplicationLanguageChangedEventHandler(object source, AUIApplicationLanguageChangedEventArgs e);
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate void AUIApplicationRegionChangedEventHandler(object source, AUIApplicationRegionChangedEventArgs e);
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate void AUIApplicationBatteryLowEventHandler(object source, AUIApplicationBatteryLowEventArgs e);
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate void AUIApplicationMemoryLowEventHandler(object source, AUIApplicationMemoryLowEventArgs e);
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate void AUIApplicationAppControlEventHandler(object source, AUIApplicationAppControlEventArgs e);
+
+%}
+
+%enddef
+
+
+%define APPLICATION_EVENTHANDLER_TYPEMAP_HELPER(NameSpace, ClassName)
+  %typemap(cscode) NameSpace::ClassName %{
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    private delegate void AUIApplicationInitEventCallbackDelegate(IntPtr application);
+    private AUIApplicationInitEventHandler _applicationInitEventHandler;
+    private AUIApplicationInitEventCallbackDelegate _applicationInitEventCallbackDelegate;
+
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    private delegate void AUIApplicationTerminateEventCallbackDelegate(IntPtr application);
+    private AUIApplicationTerminateEventHandler _applicationTerminateEventHandler;
+    private AUIApplicationTerminateEventCallbackDelegate _applicationTerminateEventCallbackDelegate;
+
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    private delegate void AUIApplicationPauseEventCallbackDelegate(IntPtr application);
+    private AUIApplicationPauseEventHandler _applicationPauseEventHandler;
+    private AUIApplicationPauseEventCallbackDelegate _applicationPauseEventCallbackDelegate;
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    private delegate void AUIApplicationResumeEventCallbackDelegate(IntPtr application);
+    private AUIApplicationResumeEventHandler _applicationResumeEventHandler;
+    private AUIApplicationResumeEventCallbackDelegate _applicationResumeEventCallbackDelegate;
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    private delegate void AUIApplicationResetEventCallbackDelegate(IntPtr application);
+    private AUIApplicationResetEventHandler _applicationResetEventHandler;
+    private AUIApplicationResetEventCallbackDelegate _applicationResetEventCallbackDelegate;
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    private delegate void AUIApplicationResizeEventCallbackDelegate(IntPtr application);
+    private AUIApplicationResizeEventHandler _applicationResizeEventHandler;
+    private AUIApplicationResizeEventCallbackDelegate _applicationResizeEventCallbackDelegate;
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    private delegate void AUIApplicationLanguageChangedEventCallbackDelegate(IntPtr application);
+    private AUIApplicationLanguageChangedEventHandler _applicationLanguageChangedEventHandler;
+    private AUIApplicationLanguageChangedEventCallbackDelegate _applicationLanguageChangedEventCallbackDelegate;
+
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    private delegate void AUIApplicationRegionChangedEventCallbackDelegate(IntPtr application);
+    private AUIApplicationRegionChangedEventHandler _applicationRegionChangedEventHandler;
+    private AUIApplicationRegionChangedEventCallbackDelegate _applicationRegionChangedEventCallbackDelegate;
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    private delegate void AUIApplicationBatteryLowEventCallbackDelegate(IntPtr application);
+    private AUIApplicationBatteryLowEventHandler _applicationBatteryLowEventHandler;
+    private AUIApplicationBatteryLowEventCallbackDelegate _applicationBatteryLowEventCallbackDelegate;
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    private delegate void AUIApplicationMemoryLowEventCallbackDelegate(IntPtr application);
+    private AUIApplicationMemoryLowEventHandler _applicationMemoryLowEventHandler;
+    private AUIApplicationMemoryLowEventCallbackDelegate _applicationMemoryLowEventCallbackDelegate;
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    private delegate void AUIApplicationAppControlEventCallbackDelegate(IntPtr application, IntPtr voidp);
+    private AUIApplicationAppControlEventHandler _applicationAppControlEventHandler;
+    private AUIApplicationAppControlEventCallbackDelegate _applicationAppControlEventCallbackDelegate;
+
+    /**
+      * @brief Event for Initialized signal which can be used to subscribe/unsubscribe the event handler
+      * (in the type of AUIApplicationInitEventHandler) provided by the user.
+      * Initialized signal is emitted when application is initialised
+      */
+    public event AUIApplicationInitEventHandler Initialized
+    {
+      add
+      {
+        lock(this)
+        {
+          // Restricted to only one listener
+          if (_applicationInitEventHandler == null)
+          {
+            _applicationInitEventHandler += value;
+
+            _applicationInitEventCallbackDelegate = new AUIApplicationInitEventCallbackDelegate(OnApplicationInit);
+            this.InitSignal().Connect(_applicationInitEventCallbackDelegate);
+          }
+        }
+      }
+
+      remove
+      {
+        lock(this)
+        {
+          if (_applicationInitEventHandler != null)
+          {
+            this.InitSignal().Disconnect(_applicationInitEventCallbackDelegate);
+          }
+
+          _applicationInitEventHandler -= value;
+        }
+      }
+    }
+
+    // Callback for Application InitSignal
+    private void OnApplicationInit(IntPtr data)
+    {
+      AUIApplicationInitEventArgs e = new AUIApplicationInitEventArgs();
+
+      // Populate all members of "e" (AUIApplicationInitEventArgs) with real data
+      e.Application = Application.GetApplicationFromPtr(data);
+
+      if (_applicationInitEventHandler != null)
+      {
+        //here we send all data to user event handlers
+        _applicationInitEventHandler(this, e);
+      }
+    }
+
+    /**
+      * @brief Event for Terminated signal which can be used to subscribe/unsubscribe the event handler
+      * (in the type of AUIApplicationTerminateEventHandler) provided by the user.
+      * Terminated signal is emitted when application is terminated
+      */
+    public event AUIApplicationTerminateEventHandler Terminated
+    {
+      add
+      {
+        lock(this)
+        {
+          // Restricted to only one listener
+          if (_applicationTerminateEventHandler == null)
+          {
+            _applicationTerminateEventHandler += value;
+
+            _applicationTerminateEventCallbackDelegate = new AUIApplicationTerminateEventCallbackDelegate(OnAUIApplicationTerminate);
+            this.TerminateSignal().Connect(_applicationTerminateEventCallbackDelegate);
+          }
+        }
+      }
+
+      remove
+      {
+        lock(this)
+        {
+          if (_applicationTerminateEventHandler != null)
+          {
+            this.TerminateSignal().Disconnect(_applicationTerminateEventCallbackDelegate);
+          }
+
+          _applicationTerminateEventHandler -= value;
+        }
+      }
+    }
+
+    // Callback for Application TerminateSignal
+    private void OnAUIApplicationTerminate(IntPtr data)
+    {
+      AUIApplicationTerminateEventArgs e = new AUIApplicationTerminateEventArgs();
+
+      // Populate all members of "e" (AUIApplicationTerminateEventArgs) with real data
+      e.Application = Application.GetApplicationFromPtr(data);
+
+      if (_applicationTerminateEventHandler != null)
+      {
+        //here we send all data to user event handlers
+        _applicationTerminateEventHandler(this, e);
+      }
+    }
+
+    /**
+      * @brief Event for Paused signal which can be used to subscribe/unsubscribe the event handler
+      * (in the type of AUIApplicationPauseEventHandler) provided by the user.
+      * Paused signal is emitted when application is paused
+      */
+    public event AUIApplicationPauseEventHandler Paused
+    {
+      add
+      {
+        lock(this)
+        {
+          // Restricted to only one listener
+          if (_applicationPauseEventHandler == null)
+          {
+            _applicationPauseEventHandler += value;
+
+            _applicationPauseEventCallbackDelegate = new AUIApplicationPauseEventCallbackDelegate(OnAUIApplicationPause);
+            this.PauseSignal().Connect(_applicationPauseEventCallbackDelegate);
+          }
+        }
+      }
+
+      remove
+      {
+        lock(this)
+        {
+          if (_applicationPauseEventHandler != null)
+          {
+            this.PauseSignal().Disconnect(_applicationPauseEventCallbackDelegate);
+          }
+
+          _applicationPauseEventHandler -= value;
+        }
+      }
+    }
+
+    // Callback for Application PauseSignal
+    private void OnAUIApplicationPause(IntPtr data)
+    {
+      AUIApplicationPauseEventArgs e = new AUIApplicationPauseEventArgs();
+
+      // Populate all members of "e" (AUIApplicationPauseEventArgs) with real data
+      e.Application = Application.GetApplicationFromPtr(data);
+
+      if (_applicationPauseEventHandler != null)
+      {
+        //here we send all data to user event handlers
+        _applicationPauseEventHandler(this, e);
+      }
+    }
+
+    /**
+      * @brief Event for Resumed signal which can be used to subscribe/unsubscribe the event handler
+      * (in the type of AUIApplicationResumeEventHandler) provided by the user.
+      * Resumed signal is emitted when application is resumed
+      */
+    public event AUIApplicationResumeEventHandler Resumed
+    {
+      add
+      {
+        lock(this)
+        {
+          // Restricted to only one listener
+          if (_applicationResumeEventHandler == null)
+          {
+            _applicationResumeEventHandler += value;
+
+            _applicationResumeEventCallbackDelegate = new AUIApplicationResumeEventCallbackDelegate(OnAUIApplicationResume);
+            this.ResumeSignal().Connect(_applicationResumeEventCallbackDelegate);
+          }
+        }
+      }
+
+      remove
+      {
+        lock(this)
+        {
+          if (_applicationResumeEventHandler != null)
+          {
+            this.ResumeSignal().Disconnect(_applicationResumeEventCallbackDelegate);
+          }
+
+          _applicationResumeEventHandler -= value;
+        }
+      }
+    }
+
+    // Callback for Application ResumeSignal
+    private void OnAUIApplicationResume(IntPtr data)
+    {
+      AUIApplicationResumeEventArgs e = new AUIApplicationResumeEventArgs();
+
+      // Populate all members of "e" (AUIApplicationResumeEventArgs) with real data
+      e.Application = Application.GetApplicationFromPtr(data);
+
+      if (_applicationResumeEventHandler != null)
+      {
+        //here we send all data to user event handlers
+        _applicationResumeEventHandler(this, e);
+      }
+    }
+
+    /**
+      * @brief Event for Reset signal which can be used to subscribe/unsubscribe the event handler
+      * (in the type of AUIApplicationResetEventHandler) provided by the user.
+      * Reset signal is emitted when application is reset
+      */
+    public event AUIApplicationResetEventHandler Reset
+    {
+      add
+      {
+        lock(this)
+        {
+          // Restricted to only one listener
+          if (_applicationResetEventHandler == null)
+          {
+            _applicationResetEventHandler += value;
+
+            _applicationResetEventCallbackDelegate = new AUIApplicationResetEventCallbackDelegate(OnAUIApplicationReset);
+            this.ResetSignal().Connect(_applicationResetEventCallbackDelegate);
+          }
+        }
+      }
+
+      remove
+      {
+        lock(this)
+        {
+          if (_applicationResetEventHandler != null)
+          {
+            this.ResetSignal().Disconnect(_applicationResetEventCallbackDelegate);
+          }
+
+          _applicationResetEventHandler -= value;
+        }
+      }
+    }
+
+    // Callback for Application ResetSignal
+    private void OnAUIApplicationReset(IntPtr data)
+    {
+      AUIApplicationResetEventArgs e = new AUIApplicationResetEventArgs();
+
+      // Populate all members of "e" (AUIApplicationResetEventArgs) with real data
+      e.Application = Application.GetApplicationFromPtr(data);
+
+      if (_applicationResetEventHandler != null)
+      {
+        //here we send all data to user event handlers
+        _applicationResetEventHandler(this, e);
+      }
+    }
+
+    /**
+      * @brief Event for Resized signal which can be used to subscribe/unsubscribe the event handler
+      * (in the type of AUIApplicationResizeEventHandler) provided by the user.
+      * Resized signal is emitted when application is resized
+      */
+    public event AUIApplicationResizeEventHandler Resized
+    {
+      add
+      {
+        lock(this)
+        {
+          // Restricted to only one listener
+          if (_applicationResizeEventHandler == null)
+          {
+            _applicationResizeEventHandler += value;
+
+            _applicationResizeEventCallbackDelegate = new AUIApplicationResizeEventCallbackDelegate(OnAUIApplicationResize);
+            this.ResizeSignal().Connect(_applicationResizeEventCallbackDelegate);
+          }
+        }
+      }
+
+      remove
+      {
+        lock(this)
+        {
+          if (_applicationResizeEventHandler != null)
+          {
+            this.ResizeSignal().Disconnect(_applicationResizeEventCallbackDelegate);
+          }
+
+          _applicationResizeEventHandler -= value;
+        }
+      }
+    }
+
+    // Callback for Application ResizeSignal
+    private void OnAUIApplicationResize(IntPtr data)
+    {
+      AUIApplicationResizeEventArgs e = new AUIApplicationResizeEventArgs();
+
+      // Populate all members of "e" (AUIApplicationResizeEventArgs) with real data
+      e.Application = Application.GetApplicationFromPtr(data);
+
+      if (_applicationResizeEventHandler != null)
+      {
+        //here we send all data to user event handlers
+        _applicationResizeEventHandler(this, e);
+      }
+    }
+
+    /**
+      * @brief Event for LanguageChanged signal which can be used to subscribe/unsubscribe the event handler
+      * (in the type of AUIApplicationLanguageChangedEventHandler) provided by the user.
+      * LanguageChanged signal is emitted when the region of the device is changed.
+      */
+    public event AUIApplicationLanguageChangedEventHandler LanguageChanged
+    {
+      add
+      {
+        lock(this)
+        {
+          // Restricted to only one listener
+          if (_applicationLanguageChangedEventHandler == null)
+          {
+            _applicationLanguageChangedEventHandler += value;
+
+            _applicationLanguageChangedEventCallbackDelegate = new AUIApplicationLanguageChangedEventCallbackDelegate(OnAUIApplicationLanguageChanged);
+            this.LanguageChangedSignal().Connect(_applicationLanguageChangedEventCallbackDelegate);
+          }
+        }
+      }
+
+      remove
+      {
+        lock(this)
+        {
+          if (_applicationLanguageChangedEventHandler != null)
+          {
+            this.LanguageChangedSignal().Disconnect(_applicationLanguageChangedEventCallbackDelegate);
+          }
+
+          _applicationLanguageChangedEventHandler -= value;
+        }
+      }
+    }
+
+    // Callback for Application LanguageChangedSignal
+    private void OnAUIApplicationLanguageChanged(IntPtr data)
+    {
+      AUIApplicationLanguageChangedEventArgs e = new AUIApplicationLanguageChangedEventArgs();
+
+      // Populate all members of "e" (AUIApplicationLanguageChangedEventArgs) with real data
+      e.Application = Application.GetApplicationFromPtr(data);
+
+      if (_applicationLanguageChangedEventHandler != null)
+      {
+        //here we send all data to user event handlers
+        _applicationLanguageChangedEventHandler(this, e);
+      }
+    }
+
+    /**
+      * @brief Event for RegionChanged signal which can be used to subscribe/unsubscribe the event handler
+      * (in the type of AUIApplicationRegionChangedEventHandler) provided by the user.
+      * RegionChanged signal is emitted when the region of the device is changed.
+      */
+    public event AUIApplicationRegionChangedEventHandler RegionChanged
+    {
+      add
+      {
+        lock(this)
+        {
+          // Restricted to only one listener
+          if (_applicationRegionChangedEventHandler == null)
+          {
+            _applicationRegionChangedEventHandler += value;
+
+            _applicationRegionChangedEventCallbackDelegate = new AUIApplicationRegionChangedEventCallbackDelegate(OnAUIApplicationRegionChanged);
+            this.RegionChangedSignal().Connect(_applicationRegionChangedEventCallbackDelegate);
+          }
+        }
+      }
+
+      remove
+      {
+        lock(this)
+        {
+          if (_applicationRegionChangedEventHandler != null)
+          {
+            this.RegionChangedSignal().Disconnect(_applicationRegionChangedEventCallbackDelegate);
+          }
+
+          _applicationRegionChangedEventHandler -= value;
+        }
+      }
+    }
+
+    // Callback for Application RegionChangedSignal
+    private void OnAUIApplicationRegionChanged(IntPtr data)
+    {
+      AUIApplicationRegionChangedEventArgs e = new AUIApplicationRegionChangedEventArgs();
+
+      // Populate all members of "e" (AUIApplicationRegionChangedEventArgs) with real data
+      e.Application = Application.GetApplicationFromPtr(data);
+
+      if (_applicationRegionChangedEventHandler != null)
+      {
+        //here we send all data to user event handlers
+        _applicationRegionChangedEventHandler(this, e);
+      }
+    }
+
+    /**
+      * @brief Event for BatteryLow signal which can be used to subscribe/unsubscribe the event handler
+      * (in the type of AUIApplicationBatteryLowEventHandler) provided by the user.
+      * BatteryLow signal is emitted when the battery level of the device is low.
+      */
+    public event AUIApplicationBatteryLowEventHandler BatteryLow
+    {
+      add
+      {
+        lock(this)
+        {
+          // Restricted to only one listener
+          if (_applicationBatteryLowEventHandler == null)
+          {
+            _applicationBatteryLowEventHandler += value;
+
+            _applicationBatteryLowEventCallbackDelegate = new AUIApplicationBatteryLowEventCallbackDelegate(OnAUIApplicationBatteryLow);
+            this.BatteryLowSignal().Connect(_applicationBatteryLowEventCallbackDelegate);
+          }
+        }
+      }
+
+      remove
+      {
+        lock(this)
+        {
+          if (_applicationBatteryLowEventHandler != null)
+          {
+            this.BatteryLowSignal().Disconnect(_applicationBatteryLowEventCallbackDelegate);
+          }
+
+          _applicationBatteryLowEventHandler -= value;
+        }
+      }
+    }
+
+    // Callback for Application BatteryLowSignal
+    private void OnAUIApplicationBatteryLow(IntPtr data)
+    {
+      AUIApplicationBatteryLowEventArgs e = new AUIApplicationBatteryLowEventArgs();
+
+      // Populate all members of "e" (AUIApplicationBatteryLowEventArgs) with real data
+      e.Application = Application.GetApplicationFromPtr(data);
+
+      if (_applicationBatteryLowEventHandler != null)
+      {
+        //here we send all data to user event handlers
+        _applicationBatteryLowEventHandler(this, e);
+      }
+    }
+
+    /**
+      * @brief Event for MemoryLow signal which can be used to subscribe/unsubscribe the event handler
+      * (in the type of AUIApplicationMemoryLowEventHandler) provided by the user.
+      * MemoryLow signal is emitted when the memory level of the device is low.
+      */
+    public event AUIApplicationMemoryLowEventHandler MemoryLow
+    {
+      add
+      {
+        lock(this)
+        {
+          // Restricted to only one listener
+          if (_applicationMemoryLowEventHandler == null)
+          {
+            _applicationMemoryLowEventHandler += value;
+
+            _applicationMemoryLowEventCallbackDelegate = new AUIApplicationMemoryLowEventCallbackDelegate(OnAUIApplicationMemoryLow);
+            this.MemoryLowSignal().Connect(_applicationMemoryLowEventCallbackDelegate);
+          }
+        }
+      }
+
+      remove
+      {
+        lock(this)
+        {
+          if (_applicationMemoryLowEventHandler != null)
+          {
+            this.MemoryLowSignal().Disconnect(_applicationMemoryLowEventCallbackDelegate);
+          }
+
+          _applicationMemoryLowEventHandler -= value;
+        }
+      }
+    }
+
+    // Callback for Application MemoryLowSignal
+    private void OnAUIApplicationMemoryLow(IntPtr data)
+    {
+      AUIApplicationMemoryLowEventArgs e = new AUIApplicationMemoryLowEventArgs();
+
+      // Populate all members of "e" (AUIApplicationMemoryLowEventArgs) with real data
+      e.Application = Application.GetApplicationFromPtr(data);
+
+      if (_applicationMemoryLowEventHandler != null)
+      {
+        //here we send all data to user event handlers
+        _applicationMemoryLowEventHandler(this, e);
+      }
+    }
+
+    /**
+      * @brief Event for AppControl signal which can be used to subscribe/unsubscribe the event handler
+      * (in the type of AUIApplicationAppControlEventHandler) provided by the user.
+      * AppControl signal is emitted when another application sends a launch request to the application.
+      */
+    public event AUIApplicationAppControlEventHandler AppControl
+    {
+      add
+      {
+        lock(this)
+        {
+          // Restricted to only one listener
+          if (_applicationAppControlEventHandler == null)
+          {
+            _applicationAppControlEventHandler += value;
+
+            _applicationAppControlEventCallbackDelegate = new AUIApplicationAppControlEventCallbackDelegate(OnAUIApplicationAppControl);
+            this.AppControlSignal().Connect(_applicationAppControlEventCallbackDelegate);
+          }
+        }
+      }
+
+      remove
+      {
+        lock(this)
+        {
+          if (_applicationAppControlEventHandler != null)
+          {
+            this.AppControlSignal().Disconnect(_applicationAppControlEventCallbackDelegate);
+          }
+
+          _applicationAppControlEventHandler -= value;
+        }
+      }
+    }
+
+    // Callback for Application AppControlSignal
+    private void OnAUIApplicationAppControl(IntPtr application, IntPtr voidp)
+    {
+      AUIApplicationAppControlEventArgs e = new AUIApplicationAppControlEventArgs();
+
+      // Populate all members of "e" (AUIApplicationAppControlEventArgs) with real data
+      e.Application = Application.GetApplicationFromPtr(application);
+      e.VoidP = voidp;
+
+      if (_applicationAppControlEventHandler != null)
+      {
+        //here we send all data to user event handlers
+        _applicationAppControlEventHandler(this, e);
+      }
+    }
+
+    private static  Application instance; // singleton
+
+    public delegate void InitDelegate();
+
+    public delegate void TerminateDelegate();
+
+    public delegate void PauseDelegate();
+
+    public delegate void ResumeDelegate();
+
+    public delegate void ResizeDelegate();
+
+    public delegate void AppControlDelegate();
+
+    public delegate void LanguageChangedDelegate();
+
+    public delegate void RegionChangedDelegate();
+
+    public delegate void BatteryLowDelegate();
+
+    public delegate void MemoryLowDelegate();
+
+    [System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
+    internal delegate void InitDelegateInternal();
+
+    [System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
+    internal delegate void TerminateDelegateInternal();
+
+    [System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
+    internal delegate void PauseDelegateInternal();
+
+    [System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
+    internal delegate void ResumeDelegateInternal();
+
+    [System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
+    internal delegate void ResizeDelegateInternal();
+
+    [System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
+    internal delegate void AppControlDelegateInternal();
+
+    [System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
+    internal delegate void LanguageChangedDelegateInternal();
+
+    [System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
+    internal delegate void RegionChangedDelegateInternal();
+
+    [System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
+    internal delegate void BatteryLowDelegateInternal();
+
+    [System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
+    internal delegate void MemoryLowDelegateInternal();
+
+    static void Initialize()
+    {
+      //       instance.InitDelegate();
+    }
+
+    public static Application GetApplicationFromPtr(global::System.IntPtr cPtr) {
+      Application ret = new Application(cPtr, false);
+      if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+      return ret;
+    }
+
+    internal void SetupDelegates() {
+      InitDelegateInternal initializeCallback = new InitDelegateInternal( Initialize );
+      System.Console.WriteLine( "InitSignal connection count");
+
+      this.InitSignal().Connect( initializeCallback );
+      //Console.WriteLine( "InitSignal connection count = " + app.InitSignal().GetConnectionCount() );
+    }
+
+    public static Application NewApplication() {
+      Application ret = New(1);
+      if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+
+      // we've got an application now connect the signals
+      ret.SetupDelegates();
+      // set the singleton
+
+      return ret;
+    }
+
+    %}
+    %enddef
+
+%define DALI_APPLICATION_EVENTHANDLER_PARAM( NameSpace, ClassName)
+  APPLICATION_EVENTHANDLER_TYPEMAP_EVENTARG( NameSpace, ClassName);
+  APPLICATION_EVENTHANDLER_TYPEMAP_HELPER( NameSpace, ClassName);
+  %enddef
+
+  namespace Dali
+{
+  DALI_APPLICATION_EVENTHANDLER_PARAM( Dali, Application);
+}
+
+
diff --git a/plugins/dali-swig/SWIG/events/builder-event.i b/plugins/dali-swig/SWIG/events/builder-event.i
new file mode 100644 (file)
index 0000000..ad55258
--- /dev/null
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) 2016 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.
+ *
+ */
+
+%define BUILDER_EVENTHANDLER_TYPEMAP_EVENTARG(NameSpace, ClassName)
+%typemap(csimports) NameSpace::ClassName %{
+    using System;
+    using System.Runtime.InteropServices;
+
+%}
+
+%enddef
+
+
+%define BUILDER_EVENTHANDLER_TYPEMAP_HELPER(NameSpace, ClassName)
+  %typemap(cscode) NameSpace::ClassName %{
+
+    public class QuitEventArgs : EventArgs
+    {
+    }
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate void QuitEventHandler(object source, QuitEventArgs e);
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    private delegate void QuitEventCallbackDelegate();
+    private QuitEventHandler _builderQuitEventHandler;
+    private QuitEventCallbackDelegate _builderQuitEventCallbackDelegate;
+
+    public event QuitEventHandler Quit
+    {
+      add
+      {
+        lock(this)
+        {
+          // Restricted to only one listener
+          if (_builderQuitEventHandler == null)
+          {
+            _builderQuitEventHandler += value;
+
+            _builderQuitEventCallbackDelegate = new QuitEventCallbackDelegate(OnQuit);
+            this.QuitSignal().Connect(_builderQuitEventCallbackDelegate);
+          }
+        }
+      }
+
+      remove
+      {
+        lock(this)
+        {
+          if (_builderQuitEventHandler != null)
+          {
+            this.QuitSignal().Disconnect(_builderQuitEventCallbackDelegate);
+          }
+
+          _builderQuitEventHandler -= value;
+        }
+      }
+    }
+
+    // Callback for Builder QuitSignal
+    private void OnQuit()
+    {
+      QuitEventArgs e = new QuitEventArgs();
+
+      if (_builderQuitEventHandler != null)
+      {
+        //here we send all data to user event handlers
+        _builderQuitEventHandler(this, e);
+      }
+    }
+
+    %}
+    %enddef
+
+%define DALI_BUILDER_EVENTHANDLER_PARAM( NameSpace, ClassName)
+  BUILDER_EVENTHANDLER_TYPEMAP_EVENTARG( NameSpace, ClassName);
+  BUILDER_EVENTHANDLER_TYPEMAP_HELPER( NameSpace, ClassName);
+  %enddef
+
+  namespace Dali
+{
+  DALI_BUILDER_EVENTHANDLER_PARAM( Dali::Toolkit, Builder);
+}
+
diff --git a/plugins/dali-swig/SWIG/events/button-event.i b/plugins/dali-swig/SWIG/events/button-event.i
new file mode 100644 (file)
index 0000000..041c621
--- /dev/null
@@ -0,0 +1,345 @@
+/*
+ * Copyright (c) 2016 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.
+ *
+ */
+
+// Example from Swig MACRO
+
+%define EVENTHANDLER_TYPEMAP_EVENTARG(NameSpace, ClassName)
+%typemap(csimports) NameSpace::ClassName %{
+using System;
+using System.Runtime.InteropServices;
+
+%}
+
+%enddef
+
+%define EVENTHANDLER_TYPEMAP_HELPER(NameSpace, ClassName)
+%typemap(cscode) NameSpace::ClassName %{
+
+public class ClickedEventArgs : EventArgs
+{
+   private Button _button;
+
+   public Button Button
+   {
+      get
+      {
+         return _button;
+      }
+      set
+      {
+         _button = value;
+      }
+   }
+}
+
+public class PressedEventArgs : EventArgs
+{
+   private Button _button;
+
+   public Button Button
+   {
+      get
+      {
+         return _button;
+      }
+      set
+      {
+         _button = value;
+      }
+   }
+}
+
+public class ReleasedEventArgs : EventArgs
+{
+   private Button _button;
+
+   public Button Button
+   {
+      get
+      {
+         return _button;
+      }
+      set
+      {
+         _button = value;
+      }
+   }
+}
+
+public class StateChangedEventArgs : EventArgs
+{
+   private Button _button;
+
+   public Button Button
+   {
+      get
+      {
+         return _button;
+      }
+      set
+      {
+         _button = value;
+      }
+   }
+}
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate bool ClickedEventHandler(object source, ClickedEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate bool PressedEventHandler(object source, PressedEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate bool ReleasedEventHandler(object source, ReleasedEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate bool StateChangedEventHandler(object source, StateChangedEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate bool ClickedCallbackDelegate(global::System.IntPtr data);
+  private ClickedEventHandler   _buttonClickedEventHandler;
+  private ClickedCallbackDelegate _buttonClickedCallbackDelegate;
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate bool PressedCallbackDelegate(global::System.IntPtr data);
+  private PressedEventHandler   _buttonPressedEventHandler;
+  private PressedCallbackDelegate _buttonPressedCallbackDelegate;
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate bool ReleasedCallbackDelegate(global::System.IntPtr data);
+  private ReleasedEventHandler   _buttonReleasedEventHandler;
+  private ReleasedCallbackDelegate _buttonReleasedCallbackDelegate;
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate bool StateChangedCallbackDelegate(global::System.IntPtr data);
+  private StateChangedEventHandler   _buttonStateChangedEventHandler;
+  private StateChangedCallbackDelegate _buttonStateChangedCallbackDelegate;
+
+
+  public event ClickedEventHandler Clicked
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_buttonClickedEventHandler == null)
+           {
+              _buttonClickedEventHandler += value;
+
+              _buttonClickedCallbackDelegate = new ClickedCallbackDelegate(OnClicked);
+              this.ClickedSignal().Connect(_buttonClickedCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_buttonClickedEventHandler != null)
+           {
+               this.ClickedSignal().Disconnect(_buttonClickedCallbackDelegate);
+           }
+
+           _buttonClickedEventHandler -= value;
+        }
+     }
+  }
+
+  // Callback for button click signal
+  private bool OnClicked (IntPtr data)
+  {
+     Button##ClickedEventArgs e = new ClickedEventArgs();
+
+     e.Button = Button.GetButtonFromPtr(data);
+
+     if (_buttonClickedEventHandler != null)
+     {
+        //here we send all data to user event handlers
+        return _buttonClickedEventHandler(this, e);
+     }
+     return false;
+  }
+
+
+  public event PressedEventHandler Pressed
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_buttonPressedEventHandler == null)
+           {
+              _buttonPressedEventHandler += value;
+
+              _buttonPressedCallbackDelegate = new PressedCallbackDelegate(OnPressed);
+              this.PressedSignal().Connect(_buttonPressedCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_buttonPressedEventHandler != null)
+           {
+               this.PressedSignal().Disconnect(_buttonPressedCallbackDelegate);
+           }
+
+           _buttonPressedEventHandler -= value;
+        }
+     }
+  }
+
+  // Callback for button click signal
+  private bool OnPressed (IntPtr data)
+  {
+     Button##PressedEventArgs e = new PressedEventArgs();
+
+     e.Button = Button.GetButtonFromPtr(data);
+
+     if (_buttonPressedEventHandler != null)
+     {
+        //here we send all data to user event handlers
+       return _buttonPressedEventHandler(this, e);
+     }
+     return false;
+  }
+
+
+  public event ReleasedEventHandler Released
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_buttonReleasedEventHandler == null)
+           {
+              _buttonReleasedEventHandler += value;
+
+              _buttonReleasedCallbackDelegate = new ReleasedCallbackDelegate(OnReleased);
+              this.ReleasedSignal().Connect(_buttonReleasedCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_buttonReleasedEventHandler != null)
+           {
+               this.ReleasedSignal().Disconnect(_buttonReleasedCallbackDelegate);
+           }
+
+           _buttonReleasedEventHandler -= value;
+        }
+     }
+  }
+
+  // Callback for button click signal
+  private bool OnReleased (IntPtr data)
+  {
+     Button##ReleasedEventArgs e = new ReleasedEventArgs();
+
+     e.Button = Button.GetButtonFromPtr(data);
+
+     if (_buttonReleasedEventHandler != null)
+     {
+        //here we send all data to user event handlers
+       return _buttonReleasedEventHandler(this, e);
+     }
+     return false;
+  }
+
+
+  public event StateChangedEventHandler StateChanged
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_buttonStateChangedEventHandler == null)
+           {
+              _buttonStateChangedEventHandler += value;
+
+              _buttonStateChangedCallbackDelegate = new StateChangedCallbackDelegate(OnStateChanged);
+              this.StateChangedSignal().Connect(_buttonStateChangedCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_buttonStateChangedEventHandler != null)
+           {
+               this.StateChangedSignal().Disconnect(_buttonStateChangedCallbackDelegate);
+           }
+
+           _buttonStateChangedEventHandler -= value;
+        }
+     }
+  }
+
+  // Callback for button click signal
+  private bool OnStateChanged (IntPtr data)
+  {
+     Button##StateChangedEventArgs e = new StateChangedEventArgs();
+
+     e.Button = Button.GetButtonFromPtr(data);
+
+     if (_buttonStateChangedEventHandler != null)
+     {
+        //here we send all data to user event handlers
+       return _buttonStateChangedEventHandler(this, e);
+     }
+     return false;
+  }
+
+ public static ClassName Get ## ClassName ## FromPtr(global::System.IntPtr cPtr) {
+    ClassName ret = new ClassName(cPtr, false);
+   if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+    return ret;
+  }
+
+%}
+%enddef
+
+
+%define BUTTON_EVENTHANDLER_PARAM( NameSpace, ClassName)
+
+  BUTTON_EVENTHANDLER_TYPEMAP_EVENTARG( NameSpace, ClassName);
+  BUTTON_EVENTHANDLER_TYPEMAP_HELPER( NameSpace, ClassName);
+
+%enddef
+
+namespace Dali
+{
+  BUTTON_EVENTHANDLER_PARAM( Dali::Toolkit, Button);
+
+} // namespace DALi
+
+
+
+
diff --git a/plugins/dali-swig/SWIG/events/control-event.i b/plugins/dali-swig/SWIG/events/control-event.i
new file mode 100644 (file)
index 0000000..79b9034
--- /dev/null
@@ -0,0 +1,321 @@
+/*
+ * Copyright (c) 2016 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.
+ *
+ */
+
+%define CONTROL_EVENTHANDLER_TYPEMAP_EVENTARG(NameSpace, ClassName)
+%typemap(csimports) NameSpace::ClassName %{
+using System;
+using System.Runtime.InteropServices;
+
+%}
+
+%enddef
+
+%define CONTROL_EVENTHANDLER_TYPEMAP_HELPER(NameSpace, ClassName)
+%typemap(cscode) NameSpace::ClassName %{
+
+
+/**
+  * @brief Event arguments that passed via KeyInputFocusGained signal
+  *
+  */
+public class KeyInputFocusGainedEventArgs : EventArgs
+{
+   private Control _control;
+
+   /**
+     * @brief Control - is the control that gets Key Input Focus
+     *
+     */
+   public Control Control
+   {
+      get
+      {
+         return _control;
+      }
+      set
+      {
+         _control = value;
+      }
+   }
+}
+
+/**
+  * @brief Event arguments that passed via KeyInputFocusLost signal
+  *
+  */
+public class KeyInputFocusLostEventArgs : EventArgs
+{
+   private Control _control;
+
+   /**
+     * @brief Control - is the control that loses Key Input Focus
+     *
+     */
+   public Control Control
+   {
+      get
+      {
+         return _control;
+      }
+      set
+      {
+         _control = value;
+      }
+   }
+}
+
+/**
+  * @brief Event arguments that passed via KeyEvent signal
+  *
+  */
+public class KeyEventArgs : EventArgs
+{
+   private Control _control;
+   private KeyEvent _keyEvent;
+
+   /**
+     * @brief Control - is the control that recieves the keyevent.
+     *
+     */
+   public Control Control
+   {
+      get
+      {
+         return _control;
+      }
+      set
+      {
+         _control = value;
+      }
+   }
+
+   /**
+     * @brief KeyEvent - is the keyevent sent to the Control.
+     *
+     */
+   public KeyEvent KeyEvent
+   {
+      get
+      {
+         return _keyEvent;
+      }
+      set
+      {
+         _keyEvent = value;
+      }
+   }
+}
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate void KeyInputFocusGainedEventHandler(object source, KeyInputFocusGainedEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate void KeyInputFocusLostEventHandler(object source, KeyInputFocusLostEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate bool KeyEventHandler(object source, KeyEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate void KeyInputFocusGainedCallbackDelegate(IntPtr control);
+  private KeyInputFocusGainedEventHandler _KeyInputFocusGainedEventHandler;
+  private KeyInputFocusGainedCallbackDelegate _KeyInputFocusGainedCallbackDelegate;
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate void KeyInputFocusLostCallbackDelegate(IntPtr control);
+  private KeyInputFocusLostEventHandler _KeyInputFocusLostEventHandler;
+  private KeyInputFocusLostCallbackDelegate _KeyInputFocusLostCallbackDelegate;
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate bool KeyCallbackDelegate(IntPtr control, IntPtr keyEvent);
+  private KeyEventHandler _KeyEventHandler;
+  private KeyCallbackDelegate _KeyCallbackDelegate;
+
+  /**
+    * @brief Event for KeyInputFocusGained signal which can be used to subscribe/unsubscribe the event handler
+    * (in the type of KeyInputFocusGainedEventHandler) provided by the user.
+    * KeyInputFocusGained signal is emitted when the control gets Key Input Focus.
+    */
+  public event KeyInputFocusGainedEventHandler KeyInputFocusGained
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_KeyInputFocusGainedEventHandler == null)
+           {
+              _KeyInputFocusGainedEventHandler += value;
+
+              _KeyInputFocusGainedCallbackDelegate = new KeyInputFocusGainedCallbackDelegate(OnKeyInputFocusGained);
+              this.KeyInputFocusGainedSignal().Connect(_KeyInputFocusGainedCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_KeyInputFocusGainedEventHandler != null)
+           {
+              this.KeyInputFocusGainedSignal().Disconnect(_KeyInputFocusGainedCallbackDelegate);
+           }
+
+           _KeyInputFocusGainedEventHandler -= value;
+        }
+     }
+  }
+
+ private void OnKeyInputFocusGained(IntPtr control)
+  {
+   KeyInputFocusGainedEventArgs e = new KeyInputFocusGainedEventArgs();
+
+   // Populate all members of "e" (KeyInputFocusGainedEventArgs) with real data
+   e.Control = Dali.Control.GetControlFromPtr(control);
+
+   if (_KeyInputFocusGainedEventHandler != null)
+   {
+      //here we send all data to user event handlers
+      _KeyInputFocusGainedEventHandler(this, e);
+   }
+
+  }
+
+  /**
+    * @brief Event for KeyInputFocusLost signal which can be used to subscribe/unsubscribe the event handler
+    * (in the type of KeyInputFocusLostEventHandler) provided by the user.
+    * KeyInputFocusLost signal is emitted when the control loses Key Input Focus.
+    */
+  public event KeyInputFocusLostEventHandler KeyInputFocusLost
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_KeyInputFocusLostEventHandler == null)
+           {
+              _KeyInputFocusLostEventHandler += value;
+
+              _KeyInputFocusLostCallbackDelegate = new KeyInputFocusLostCallbackDelegate(OnKeyInputFocusLost);
+              this.KeyInputFocusLostSignal().Connect(_KeyInputFocusLostCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_KeyInputFocusLostEventHandler != null)
+           {
+              this.KeyInputFocusLostSignal().Disconnect(_KeyInputFocusLostCallbackDelegate);
+           }
+
+           _KeyInputFocusLostEventHandler -= value;
+        }
+     }
+  }
+
+ private void OnKeyInputFocusLost(IntPtr control)
+  {
+   KeyInputFocusLostEventArgs e = new KeyInputFocusLostEventArgs();
+
+   // Populate all members of "e" (KeyInputFocusLostEventArgs) with real data
+   e.Control = Dali.Control.GetControlFromPtr(control);
+
+   if (_KeyInputFocusLostEventHandler != null)
+   {
+      //here we send all data to user event handlers
+      _KeyInputFocusLostEventHandler(this, e);
+   }
+  }
+
+  /**
+    * @brief Event for KeyPressed signal which can be used to subscribe/unsubscribe the event handler
+    * (in the type of KeyEventEventHandler) provided by the user.
+    * KeyPressed signal is emitted when key event is received.
+    */
+  public event KeyEventHandler KeyPressed
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_KeyEventHandler == null)
+           {
+              _KeyEventHandler += value;
+
+              _KeyCallbackDelegate = new KeyCallbackDelegate(OnKeyEvent);
+              this.KeyEventSignal().Connect(_KeyCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_KeyEventHandler != null)
+           {
+              this.KeyEventSignal().Disconnect(_KeyCallbackDelegate);
+           }
+
+           _KeyEventHandler -= value;
+        }
+     }
+  }
+
+ private bool OnKeyEvent(IntPtr control, IntPtr keyEvent)
+  {
+   KeyEventArgs e = new KeyEventArgs();
+
+   // Populate all members of "e" (KeyEventArgs) with real data
+   e.Control = Dali.Control.GetControlFromPtr(control);
+        e.KeyEvent = Dali.KeyEvent.GetKeyEventFromPtr(keyEvent);
+
+   if (_KeyEventHandler != null)
+   {
+      //here we send all data to user event handlers
+      return _KeyEventHandler(this, e);
+   }
+   return false;
+
+  }
+
+ public static ClassName Get ## ClassName ## FromPtr(global::System.IntPtr cPtr) {
+    ClassName ret = new ClassName(cPtr, false);
+   if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+    return ret;
+  }
+
+%}
+
+%enddef
+
+%define DALI_CONTROL_EVENTHANDLER_PARAM( NameSpace, ClassName)
+
+  CONTROL_EVENTHANDLER_TYPEMAP_EVENTARG( NameSpace, ClassName);
+  CONTROL_EVENTHANDLER_TYPEMAP_HELPER( NameSpace, ClassName);
+
+%enddef
+
+namespace Dali
+{
+  DALI_CONTROL_EVENTHANDLER_PARAM( Dali::Toolkit, Control);
+}
diff --git a/plugins/dali-swig/SWIG/events/gaussian-blur-view-event.i b/plugins/dali-swig/SWIG/events/gaussian-blur-view-event.i
new file mode 100644 (file)
index 0000000..1ab5c1b
--- /dev/null
@@ -0,0 +1,121 @@
+/*
+ * Copyright (c) 2016 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.
+ *
+ */
+
+%define GAUSSIAN_BLURR_VIEW_EVENTHANDLER_TYPEMAP_EVENTARG(NameSpace, ClassName)
+%typemap(csimports) NameSpace::ClassName %{
+using System;
+using System.Runtime.InteropServices;
+
+%}
+
+%enddef
+
+%define GAUSSIAN_BLURR_VIEW_EVENTHANDLER_TYPEMAP_HELPER(NameSpace, ClassName)
+%typemap(cscode) NameSpace::ClassName %{
+
+
+public class FinishedEventArgs : EventArgs
+{
+   private GaussianBlurView _gaussianBlurView;
+
+   public GaussianBlurView GaussianBlurView
+   {
+      get
+      {
+         return _gaussianBlurView;
+      }
+      set
+      {
+         _gaussianBlurView = value;
+      }
+   }
+}
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate void FinishedEventHandler(object source, FinishedEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate void FinishedEventCallbackDelegate(IntPtr application);
+  private FinishedEventHandler _gaussianFinishedEventHandler;
+  private FinishedEventCallbackDelegate _gaussianFinishedEventCallbackDelegate;
+
+  public event FinishedEventHandler Finished
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_gaussianFinishedEventHandler == null)
+           {
+              _gaussianFinishedEventHandler += value;
+
+              _gaussianFinishedEventCallbackDelegate = new FinishedEventCallbackDelegate(OnFinished);
+              this.FinishedSignal().Connect(_gaussianFinishedEventCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_gaussianFinishedEventHandler != null)
+           {
+              this.FinishedSignal().Disconnect(_gaussianFinishedEventCallbackDelegate);
+           }
+
+           _gaussianFinishedEventHandler -= value;
+        }
+     }
+  }
+
+  // Callback for GaussianBlurView FinishedSignal
+  private void OnFinished(IntPtr data)
+  {
+     FinishedEventArgs e = new FinishedEventArgs();
+
+     // Populate all members of "e" (FinishedEventArgs) with real data
+     e.GaussianBlurView = GaussianBlurView.GetGaussianBlurViewFromPtr(data);
+
+     if (_gaussianFinishedEventHandler != null)
+     {
+        //here we send all data to user event handlers
+        _gaussianFinishedEventHandler(this, e);
+     }
+  }
+
+ public static ClassName Get ## ClassName ## FromPtr(global::System.IntPtr cPtr) {
+    ClassName ret = new ClassName(cPtr, false);
+   if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+    return ret;
+  }
+
+%}
+%enddef
+
+%define DALI_GAUSSIAN_BLURR_VIEW_EVENTHANDLER_PARAM( NameSpace, ClassName)
+  GAUSSIAN_BLURR_VIEW_EVENTHANDLER_TYPEMAP_EVENTARG( NameSpace, ClassName);
+  GAUSSIAN_BLURR_VIEW_EVENTHANDLER_TYPEMAP_HELPER( NameSpace, ClassName);
+%enddef
+
+namespace Dali
+{
+  DALI_GAUSSIAN_BLURR_VIEW_EVENTHANDLER_PARAM( Dali::Toolkit, GaussianBlurView);
+}
+
+
diff --git a/plugins/dali-swig/SWIG/events/image-event.i b/plugins/dali-swig/SWIG/events/image-event.i
new file mode 100644 (file)
index 0000000..e42b869
--- /dev/null
@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) 2016 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.
+ *
+ */
+
+%define IMAGE_EVENTHANDLER_TYPEMAP_EVENTARG(NameSpace, ClassName)
+%typemap(csimports) NameSpace::ClassName %{
+using System;
+using System.Runtime.InteropServices;
+
+%}
+%enddef
+
+%define IMAGE_EVENTHANDLER_TYPEMAP_HELPER(NameSpace, ClassName)
+%typemap(cscode) NameSpace::ClassName %{
+
+
+/**
+  * @brief Event arguments that passed via Uploaded signal
+  *
+  */
+public class UploadedEventArgs : EventArgs
+{
+   private Image _image;
+   /**
+     * @brief Image - is the image data that gets uploaded to GL.
+     *
+     */
+   public Image Image
+   {
+      get
+      {
+         return _image;
+      }
+      set
+      {
+         _image = value;
+      }
+   }
+}
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate void UploadedEventHandler(object source, UploadedEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate void UploadedEventCallbackDelegate(IntPtr image);
+  private UploadedEventHandler _imageUploadedEventHandler;
+  private UploadedEventCallbackDelegate _imageUploadedEventCallbackDelegate;
+
+  /**
+    * @brief Event for Uploaded signal which can be used to subscribe/unsubscribe the event handler
+    * (in the type of UploadedEventHandler) provided by the user.
+    * Uploaded signal is emitted when the image data gets uploaded to GL.
+    */
+  public event UploadedEventHandler Uploaded
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_imageUploadedEventHandler == null)
+           {
+              _imageUploadedEventHandler += value;
+
+              _imageUploadedEventCallbackDelegate = new UploadedEventCallbackDelegate(OnUploaded);
+              this.UploadedSignal().Connect(_imageUploadedEventCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_imageUploadedEventHandler != null)
+           {
+              this.UploadedSignal().Disconnect(_imageUploadedEventCallbackDelegate);
+           }
+
+           _imageUploadedEventHandler -= value;
+        }
+     }
+  }
+
+  // Callback for Image UploadedSignal
+  private void OnUploaded(IntPtr data)
+  {
+     UploadedEventArgs e = new UploadedEventArgs();
+
+     // Populate all members of "e" (UploadedEventArgs) with real data
+     e.Image = Image.GetImageFromPtr(data);
+
+     if (_imageUploadedEventHandler != null)
+     {
+        //here we send all data to user event handlers
+        _imageUploadedEventHandler(this, e);
+     }
+  }
+
+
+public static ClassName Get ## ClassName ## FromPtr(global::System.IntPtr cPtr) {
+    ClassName ret = new ClassName(cPtr, false);
+   if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+    return ret;
+  }
+
+%}
+
+%enddef
+
+
+%define DALI_IMAGE_EVENTHANDLER_PARAM( NameSpace, ClassName)
+  IMAGE_EVENTHANDLER_TYPEMAP_EVENTARG( NameSpace, ClassName);
+  IMAGE_EVENTHANDLER_TYPEMAP_HELPER( NameSpace, ClassName);
+%enddef
+
+namespace Dali
+{
+  DALI_IMAGE_EVENTHANDLER_PARAM( Dali, Image);
+}
diff --git a/plugins/dali-swig/SWIG/events/itemview-event.i b/plugins/dali-swig/SWIG/events/itemview-event.i
new file mode 100644 (file)
index 0000000..608bbff
--- /dev/null
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2016 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.
+ *
+ */
+
+%define ITEMVIEW_EVENTHANDLER_TYPEMAP_EVENTARG(NameSpace, ClassName)
+%typemap(csimports) NameSpace::ClassName %{
+using System;
+using System.Runtime.InteropServices;
+
+%}
+%enddef
+
+
+%define ITEMVIEW_EVENTHANDLER_TYPEMAP_HELPER(NameSpace, ClassName)
+%typemap(cscode) NameSpace::ClassName %{
+
+  public class LayoutActivatedEventArgs : EventArgs
+  {
+  }
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate void LayoutActivatedEventHandler(object source, LayoutActivatedEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate void LayoutActivatedEventCallbackDelegate();
+  private LayoutActivatedEventHandler _itemViewLayoutActivatedEventHandler;
+  private LayoutActivatedEventCallbackDelegate _itemViewLayoutActivatedEventCallbackDelegate;
+
+  public event LayoutActivatedEventHandler LayoutActivated
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_itemViewLayoutActivatedEventHandler == null)
+           {
+              _itemViewLayoutActivatedEventHandler += value;
+
+              _itemViewLayoutActivatedEventCallbackDelegate = new LayoutActivatedEventCallbackDelegate(OnLayoutActivated);
+              this.LayoutActivatedSignal().Connect(_itemViewLayoutActivatedEventCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_itemViewLayoutActivatedEventHandler != null)
+           {
+              this.LayoutActivatedSignal().Disconnect(_itemViewLayoutActivatedEventCallbackDelegate);
+           }
+
+           _itemViewLayoutActivatedEventHandler -= value;
+        }
+     }
+  }
+
+  // Callback for ItemView LayoutActivatedSignal
+  private void OnLayoutActivated()
+  {
+     LayoutActivatedEventArgs e = new LayoutActivatedEventArgs();
+
+     if (_itemViewLayoutActivatedEventHandler != null)
+     {
+        //here we send all data to user event handlers
+        _itemViewLayoutActivatedEventHandler(this, e);
+     }
+  }
+
+%}
+%enddef
+
+%define DALI_ITEMVIEW_EVENTHANDLER_PARAM( NameSpace, ClassName)
+  ITEMVIEW_EVENTHANDLER_TYPEMAP_EVENTARG( NameSpace, ClassName);
+  ITEMVIEW_EVENTHANDLER_TYPEMAP_HELPER( NameSpace, ClassName);
+%enddef
+
+namespace Dali
+{
+  DALI_ITEMVIEW_EVENTHANDLER_PARAM( Dali::Toolkit, ItemView);
+}
+
diff --git a/plugins/dali-swig/SWIG/events/keyboardFocusManager-event.i b/plugins/dali-swig/SWIG/events/keyboardFocusManager-event.i
new file mode 100644 (file)
index 0000000..cca3b4a
--- /dev/null
@@ -0,0 +1,330 @@
+/*
+ * Copyright (c) 2016 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.
+ *
+ */
+
+%define KEYBOARD_FOCUS_MANAGER_EVENTHANDLER_TYPEMAP_EVENTARG(NameSpace, ClassName)
+%typemap(csimports) NameSpace::ClassName %{
+using System;
+using System.Runtime.InteropServices;
+%}
+
+%enddef
+
+
+%define KEYBOARD_FOCUS_MANAGER_EVENTHANDLER_TYPEMAP_HELPER(NameSpace, ClassName)
+%typemap(cscode) NameSpace::ClassName %{
+
+/**
+  * @brief Event arguments that passed via FocusChanged signal
+  *
+  */
+public class FocusChangedEventArgs : EventArgs
+{
+   private Actor _actorCurrent;
+   private Actor _actorNext;
+
+   /**
+     * @brief Actor - is the original focused Actor
+     *
+     */
+   public Actor ActorCurrent
+   {
+      get
+      {
+         return _actorCurrent;
+      }
+      set
+      {
+         _actorCurrent = value;
+      }
+   }
+
+   /**
+     * @brief Actor - is the current focused Actor
+     *
+     */
+   public Actor ActorNext
+   {
+      get
+      {
+         return _actorNext;
+      }
+      set
+      {
+         _actorNext = value;
+      }
+   }
+}
+
+/**
+  * @brief Event arguments that passed via FocusGroupChanged signal
+  *
+  */
+public class FocusGroupChangedEventArgs : EventArgs
+{
+   private Actor _currentFocusedActor;
+   private bool _forwardDirection;
+
+   /**
+     * @brief Actor - is the current focused Actor
+     *
+     */
+   public Actor CurrentFocusedActor
+   {
+      get
+      {
+         return _currentFocusedActor;
+      }
+      set
+      {
+         _currentFocusedActor = value;
+      }
+   }
+
+   /**
+     * @brief ForwardDirection - is the direction (forward or backward) in which to move the focus next
+     *
+     */
+   public bool ForwardDirection
+   {
+      get
+      {
+         return _forwardDirection;
+      }
+      set
+      {
+         _forwardDirection = value;
+      }
+   }
+}
+
+/**
+  * @brief Event arguments that passed via FocusedActorEnterKey signal
+  *
+  */
+public class FocusedActorEnterKeyEventArgs : EventArgs
+{
+   private Actor _actor;
+
+   /**
+     * @brief Actor - is the current focused Actor which has the enter key pressed on it.
+     *
+     */
+   public Actor Actor
+   {
+      get
+      {
+         return _actor;
+      }
+      set
+      {
+         _actor = value;
+      }
+   }
+}
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate void FocusChangedEventHandler(object source, FocusChangedEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate void FocusGroupChangedEventHandler(object source, FocusGroupChangedEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate void FocusedActorEnterKeyEventHandler(object source, FocusedActorEnterKeyEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate void FocusChangedEventCallbackDelegate(IntPtr actorCurrent, IntPtr actorNext);
+  private FocusChangedEventHandler _keyboardFocusManagerFocusChangedEventHandler;
+  private FocusChangedEventCallbackDelegate _keyboardFocusManagerFocusChangedEventCallbackDelegate;
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate void FocusGroupChangedEventCallbackDelegate(IntPtr currentFocusedActor, bool forwardDirection);
+  private FocusGroupChangedEventHandler _keyboardFocusManagerFocusGroupChangedEventHandler;
+  private FocusGroupChangedEventCallbackDelegate _keyboardFocusManagerFocusGroupChangedEventCallbackDelegate;
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate void FocusedActorEnterKeyEventCallbackDelegate(IntPtr actor);
+  private FocusedActorEnterKeyEventHandler _keyboardFocusManagerFocusedActorEnterKeyEventHandler;
+  private FocusedActorEnterKeyEventCallbackDelegate _keyboardFocusManagerFocusedActorEnterKeyEventCallbackDelegate;
+
+  /**
+    * @brief Event for FocusChanged signal which can be used to subscribe/unsubscribe the event handler
+    * (in the type of FocusChangedEventHandler) provided by the user.
+    * FocusChanged signal is emitted after the current focused actor has been changed.
+    */
+  public event FocusChangedEventHandler FocusChanged
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_keyboardFocusManagerFocusChangedEventHandler == null)
+           {
+              _keyboardFocusManagerFocusChangedEventHandler += value;
+
+              _keyboardFocusManagerFocusChangedEventCallbackDelegate = new FocusChangedEventCallbackDelegate(OnFocusChanged);
+              this.FocusChangedSignal().Connect(_keyboardFocusManagerFocusChangedEventCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_keyboardFocusManagerFocusChangedEventHandler != null)
+           {
+              this.FocusChangedSignal().Disconnect(_keyboardFocusManagerFocusChangedEventCallbackDelegate);
+           }
+
+           _keyboardFocusManagerFocusChangedEventHandler -= value;
+        }
+     }
+  }
+
+  // Callback for KeyboardFocusManager FocusChangedSignal
+  private void OnFocusChanged(IntPtr actorCurrent, IntPtr actorNext)
+  {
+     FocusChangedEventArgs e = new FocusChangedEventArgs();
+
+     // Populate all members of "e" (FocusChangedEventArgs) with real data
+     e.ActorCurrent = Actor.GetActorFromPtr(actorCurrent);
+     e.ActorNext = Actor.GetActorFromPtr(actorNext);
+
+     if (_keyboardFocusManagerFocusChangedEventHandler != null)
+     {
+        //here we send all data to user event handlers
+        _keyboardFocusManagerFocusChangedEventHandler(this, e);
+     }
+  }
+
+  /**
+    * @brief Event for FocusGroupChanged signal which can be used to subscribe/unsubscribe the event handler
+    * (in the type of FocusGroupChangedEventHandler) provided by the user.
+    * FocusGroupChanged signal is emitted when the focus group has been changed.
+    */
+  public event FocusGroupChangedEventHandler FocusGroupChanged
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_keyboardFocusManagerFocusGroupChangedEventHandler == null)
+           {
+              _keyboardFocusManagerFocusGroupChangedEventHandler += value;
+
+              _keyboardFocusManagerFocusGroupChangedEventCallbackDelegate = new FocusGroupChangedEventCallbackDelegate(OnFocusGroupChanged);
+              this.FocusGroupChangedSignal().Connect(_keyboardFocusManagerFocusGroupChangedEventCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_keyboardFocusManagerFocusGroupChangedEventHandler != null)
+           {
+              this.FocusGroupChangedSignal().Disconnect(_keyboardFocusManagerFocusGroupChangedEventCallbackDelegate);
+           }
+
+           _keyboardFocusManagerFocusGroupChangedEventHandler -= value;
+        }
+     }
+  }
+
+  // Callback for KeyboardFocusManager FocusGroupChangedSignal
+  private void OnFocusGroupChanged(IntPtr currentFocusedActor, bool forwardDirection)
+  {
+     FocusGroupChangedEventArgs e = new FocusGroupChangedEventArgs();
+
+     // Populate all members of "e" (FocusGroupChangedEventArgs) with real data
+     e.CurrentFocusedActor = Actor.GetActorFromPtr(currentFocusedActor);
+     e.ForwardDirection = forwardDirection;
+
+     if (_keyboardFocusManagerFocusGroupChangedEventHandler != null)
+     {
+        //here we send all data to user event handlers
+        _keyboardFocusManagerFocusGroupChangedEventHandler(this, e);
+     }
+  }
+
+  /**
+    * @brief Event for FocusedActorEnterKeyPressed signal which can be used to subscribe/unsubscribe the event handler
+    * (in the type of FocusedActorEnterKeyEventHandler) provided by the user.
+    * FocusedActorEnterKeyPressed signal is emitted when the current focused actor has the enter key pressed on it.
+    */
+  public event FocusedActorEnterKeyEventHandler FocusedActorEnterKeyPressed
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_keyboardFocusManagerFocusedActorEnterKeyEventHandler == null)
+           {
+              _keyboardFocusManagerFocusedActorEnterKeyEventHandler += value;
+
+              _keyboardFocusManagerFocusedActorEnterKeyEventCallbackDelegate = new FocusedActorEnterKeyEventCallbackDelegate(OnFocusedActorEnterKey);
+              this.FocusedActorEnterKeySignal().Connect(_keyboardFocusManagerFocusedActorEnterKeyEventCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_keyboardFocusManagerFocusedActorEnterKeyEventHandler != null)
+           {
+              this.FocusedActorEnterKeySignal().Disconnect(_keyboardFocusManagerFocusedActorEnterKeyEventCallbackDelegate);
+           }
+
+           _keyboardFocusManagerFocusedActorEnterKeyEventHandler -= value;
+        }
+     }
+  }
+
+  // Callback for KeyboardFocusManager FocusedActorEnterKeySignal
+  private void OnFocusedActorEnterKey(IntPtr actor)
+  {
+     FocusedActorEnterKeyEventArgs e = new FocusedActorEnterKeyEventArgs();
+
+     // Populate all members of "e" (FocusedActorEnterKeyEventArgs) with real data
+     e.Actor = Actor.GetActorFromPtr(actor);
+
+     if (_keyboardFocusManagerFocusedActorEnterKeyEventHandler != null)
+     {
+        //here we send all data to user event handlers
+        _keyboardFocusManagerFocusedActorEnterKeyEventHandler(this, e);
+     }
+  }
+
+%}
+%enddef
+
+%define DALI_KEYBOARD_FOCUS_MANAGER_EVENTHANDLER_PARAM( NameSpace, ClassName)
+  KEYBOARD_FOCUS_MANAGER_EVENTHANDLER_TYPEMAP_EVENTARG( NameSpace, ClassName);
+  KEYBOARD_FOCUS_MANAGER_EVENTHANDLER_TYPEMAP_HELPER( NameSpace, ClassName);
+%enddef
+
+namespace Dali
+{
+  DALI_KEYBOARD_FOCUS_MANAGER_EVENTHANDLER_PARAM( Dali::Toolkit, KeyboardFocusManager);
+}
+
diff --git a/plugins/dali-swig/SWIG/events/longpressgesture-event.i b/plugins/dali-swig/SWIG/events/longpressgesture-event.i
new file mode 100644 (file)
index 0000000..252aec2
--- /dev/null
@@ -0,0 +1,136 @@
+/*
+ * Copyright (c) 2016 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.
+ *
+ */
+
+%define LongPressGesture_EVENTHANDLER_TYPEMAP_EVENTARG(NameSpace, ClassName)
+%typemap(csimports) NameSpace::ClassName %{
+using System;
+using System.Runtime.InteropServices;
+%}
+%enddef
+
+%define LongPressGesture_EVENTHANDLER_TYPEMAP_HELPER(NameSpace, ClassName)
+%typemap(cscode) NameSpace::ClassName %{
+
+
+public class DetectedEventArgs : EventArgs
+{
+   private Actor _actor;
+   private LongPressGesture _longPressGesture;
+
+   public Actor Actor
+   {
+      get
+      {
+         return _actor;
+      }
+      set
+      {
+         _actor = value;
+      }
+   }
+
+   public LongPressGesture LongPressGesture
+   {
+      get
+      {
+         return _longPressGesture;
+      }
+      set
+      {
+         _longPressGesture = value;
+      }
+   }
+}
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate void DetectedEventHandler(object source, DetectedEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate void DetectedCallbackDelegate(IntPtr actor, IntPtr longPressGesture);
+  private DetectedEventHandler _longPressGestureEventHandler;
+  private DetectedCallbackDelegate _longPressGestureCallbackDelegate;
+
+
+  public event DetectedEventHandler Detected
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_longPressGestureEventHandler == null)
+           {
+              _longPressGestureEventHandler += value;
+
+              _longPressGestureCallbackDelegate = new DetectedCallbackDelegate(OnLongPressGestureDetected);
+              this.DetectedSignal().Connect(_longPressGestureCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_longPressGestureEventHandler != null)
+           {
+              this.DetectedSignal().Disconnect(_longPressGestureCallbackDelegate);
+           }
+
+           _longPressGestureEventHandler -= value;
+        }
+     }
+  }
+
+ private void OnLongPressGestureDetected(IntPtr actor, IntPtr longPressGesture)
+  {
+   DetectedEventArgs e = new DetectedEventArgs();
+
+   // Populate all members of "e" (LongPressGestureEventArgs) with real data
+   e.Actor = Actor.GetActorFromPtr(actor);
+   e.LongPressGesture = Dali.LongPressGesture.GetLongPressGestureFromPtr(longPressGesture);
+
+   if (_longPressGestureEventHandler != null)
+   {
+      //here we send all data to user event handlers
+      _longPressGestureEventHandler(this, e);
+   }
+
+  }
+
+
+public static ClassName Get ## ClassName ## FromPtr(global::System.IntPtr cPtr) {
+    ClassName ret = new ClassName(cPtr, false);
+   if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+    return ret;
+  }
+
+%}
+
+%enddef
+
+%define DALI_longPressGesture_EVENTHANDLER_PARAM( NameSpace, ClassName)
+
+  LongPressGesture_EVENTHANDLER_TYPEMAP_EVENTARG( NameSpace, ClassName);
+  LongPressGesture_EVENTHANDLER_TYPEMAP_HELPER( NameSpace, ClassName);
+
+%enddef
+
+namespace Dali
+{
+  DALI_longPressGesture_EVENTHANDLER_PARAM( Dali, LongPressGestureDetector);
+}
diff --git a/plugins/dali-swig/SWIG/events/objectregistry-event.i b/plugins/dali-swig/SWIG/events/objectregistry-event.i
new file mode 100644 (file)
index 0000000..83be37d
--- /dev/null
@@ -0,0 +1,196 @@
+/*
+ * Copyright (c) 2016 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.
+ *
+ */
+
+%define OBJECT_REGISTRY_EVENTHANDLER_TYPEMAP_EVENTARG(NameSpace, ClassName)
+%typemap(csimports) NameSpace::ClassName %{
+using System;
+using System.Runtime.InteropServices;
+
+%}
+
+%enddef
+
+
+%define OBJECT_REGISTRY_EVENTHANDLER_TYPEMAP_HELPER(NameSpace, ClassName)
+%typemap(cscode) NameSpace::ClassName %{
+
+
+public class ObjectCreatedEventArgs : EventArgs
+{
+   private BaseHandle _baseHandle;
+
+   public BaseHandle BaseHandle
+   {
+      get
+      {
+         return _baseHandle;
+      }
+      set
+      {
+         _baseHandle = value;
+      }
+   }
+}
+
+public class ObjectDestroyedEventArgs : EventArgs
+{
+   private RefObject _refObject;
+
+   public RefObject RefObject
+   {
+      get
+      {
+         return _refObject;
+      }
+      set
+      {
+         _refObject = value;
+      }
+   }
+}
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate void ObjectCreatedEventHandler(object source, ObjectCreatedEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate void ObjectDestroyedEventHandler(object source, ObjectDestroyedEventArgs e);
+
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate void ObjectCreatedEventCallbackDelegate(IntPtr baseHandle);
+  private ObjectCreatedEventHandler _objectRegistryObjectCreatedEventHandler;
+  private ObjectCreatedEventCallbackDelegate _objectRegistryObjectCreatedEventCallbackDelegate;
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate void ObjectDestroyedEventCallbackDelegate(IntPtr fefObject);
+  private ObjectDestroyedEventHandler _objectRegistryObjectDestroyedEventHandler;
+  private ObjectDestroyedEventCallbackDelegate _objectRegistryObjectDestroyedEventCallbackDelegate;
+
+  public event ObjectCreatedEventHandler ObjectCreated
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_objectRegistryObjectCreatedEventHandler == null)
+           {
+              _objectRegistryObjectCreatedEventHandler += value;
+
+              _objectRegistryObjectCreatedEventCallbackDelegate = new ObjectCreatedEventCallbackDelegate(OnObjectCreated);
+              this.ObjectCreatedSignal().Connect(_objectRegistryObjectCreatedEventCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_objectRegistryObjectCreatedEventHandler != null)
+           {
+              this.ObjectCreatedSignal().Disconnect(_objectRegistryObjectCreatedEventCallbackDelegate);
+           }
+
+           _objectRegistryObjectCreatedEventHandler -= value;
+        }
+     }
+  }
+
+  // Callback for ObjectRegistry ObjectCreatedSignal
+  private void OnObjectCreated(IntPtr baseHandle)
+  {
+     ObjectCreatedEventArgs e = new ObjectCreatedEventArgs();
+
+     // Populate all members of "e" (ObjectCreatedEventArgs) with real data
+     //e.BaseHandle = BaseHandle.GetBaseHandleFromPtr(baseHandle); //GetBaseHandleFromPtr() is not present in BaseHandle.cs. Not sure what is the reason?
+
+     if (_objectRegistryObjectCreatedEventHandler != null)
+     {
+        //here we send all data to user event handlers
+        _objectRegistryObjectCreatedEventHandler(this, e);
+     }
+  }
+
+  public event ObjectDestroyedEventHandler ObjectDestroyed
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_objectRegistryObjectDestroyedEventHandler == null)
+           {
+              _objectRegistryObjectDestroyedEventHandler += value;
+
+              _objectRegistryObjectDestroyedEventCallbackDelegate = new ObjectDestroyedEventCallbackDelegate(OnObjectDestroyed);
+              this.ObjectDestroyedSignal().Connect(_objectRegistryObjectDestroyedEventCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_objectRegistryObjectDestroyedEventHandler != null)
+           {
+              this.ObjectDestroyedSignal().Disconnect(_objectRegistryObjectDestroyedEventCallbackDelegate);
+           }
+
+           _objectRegistryObjectDestroyedEventHandler -= value;
+        }
+     }
+  }
+
+  // Callback for ObjectRegistry ObjectDestroyedSignal
+  private void OnObjectDestroyed(IntPtr refObject)
+  {
+     ObjectDestroyedEventArgs e = new ObjectDestroyedEventArgs();
+
+     // Populate all members of "e" (ObjectDestroyedEventArgs) with real data
+     e.RefObject = RefObject.GetRefObjectFromPtr(refObject);
+
+     if (_objectRegistryObjectDestroyedEventHandler != null)
+     {
+        //here we send all data to user event handlers
+        _objectRegistryObjectDestroyedEventHandler(this, e);
+     }
+  }
+
+%}
+%enddef
+
+%typemap(cscode) Dali::BaseHandle %{
+ public static BaseHandle GetBaseHandleFromPtr(global::System.IntPtr cPtr) {
+    BaseHandle ret = new BaseHandle(cPtr, false);
+   if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+    return ret;
+  }
+%}
+
+
+%define DALI_OBJECT_REGISTRY_EVENTHANDLER_PARAM( NameSpace, ClassName)
+  OBJECT_REGISTRY_EVENTHANDLER_TYPEMAP_EVENTARG( NameSpace, ClassName);
+  OBJECT_REGISTRY_EVENTHANDLER_TYPEMAP_HELPER( NameSpace, ClassName);
+%enddef
+
+namespace Dali
+{
+  DALI_OBJECT_REGISTRY_EVENTHANDLER_PARAM( Dali, ObjectRegistry);
+}
+
diff --git a/plugins/dali-swig/SWIG/events/pageturnview-event.i b/plugins/dali-swig/SWIG/events/pageturnview-event.i
new file mode 100644 (file)
index 0000000..1c491e4
--- /dev/null
@@ -0,0 +1,396 @@
+/*
+ * Copyright (c) 2016 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.
+ *
+ */
+
+%define PAGETURNVIEW_EVENTHANDLER_TYPEMAP_EVENTARG(NameSpace, ClassName)
+%typemap(csimports) NameSpace::ClassName %{
+using System;
+using System.Runtime.InteropServices;
+
+%}
+%enddef
+
+%define PAGETURNVIEW_EVENTHANDLER_TYPEMAP_HELPER(NameSpace, ClassName)
+%typemap(cscode) NameSpace::ClassName %{
+
+public class PagePanStartedEventArgs : EventArgs
+{
+   private PageTurnView _pageTurnView;
+
+   public PageTurnView PageTurnView
+   {
+      get
+      {
+         return _pageTurnView;
+      }
+      set
+      {
+         _pageTurnView = value;
+      }
+   }
+}
+
+public class PagePanFinishedEventArgs : EventArgs
+{
+   private PageTurnView _pageTurnView;
+
+   public PageTurnView PageTurnView
+   {
+      get
+      {
+         return _pageTurnView;
+      }
+      set
+      {
+         _pageTurnView = value;
+      }
+   }
+}
+
+public class PageTurnStartedEventArgs : EventArgs
+{
+   private PageTurnView _pageTurnView;
+   private uint _pageIndex;
+   private bool _isTurningForward;
+
+   public PageTurnView PageTurnView
+   {
+      get
+      {
+         return _pageTurnView;
+      }
+      set
+      {
+         _pageTurnView = value;
+      }
+   }
+
+   public uint PageIndex
+   {
+      get
+      {
+         return _pageIndex;
+      }
+      set
+      {
+         _pageIndex = value;
+      }
+   }
+
+   public bool IsTurningForward
+   {
+      get
+      {
+         return _isTurningForward;
+      }
+      set
+      {
+         _isTurningForward = value;
+      }
+   }
+
+}
+
+public class PageTurnFinishedEventArgs : EventArgs
+{
+   private PageTurnView _pageTurnView;
+   private uint _pageIndex;
+   private bool _isTurningForward;
+
+   public PageTurnView PageTurnView
+   {
+      get
+      {
+         return _pageTurnView;
+      }
+      set
+      {
+         _pageTurnView = value;
+      }
+   }
+
+   public uint PageIndex
+   {
+      get
+      {
+         return _pageIndex;
+      }
+      set
+      {
+         _pageIndex = value;
+      }
+   }
+
+   public bool IsTurningForward
+   {
+      get
+      {
+         return _isTurningForward;
+      }
+      set
+      {
+         _isTurningForward = value;
+      }
+   }
+
+}
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate void PagePanStartedEventHandler(object source, PagePanStartedEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate void PagePanFinishedEventHandler(object source, PagePanFinishedEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate void PageTurnStartedEventHandler(object source, PageTurnStartedEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate void PageTurnFinishedEventHandler(object source, PageTurnFinishedEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate void PagePanStartedCallbackDelegate(IntPtr page);
+  private PagePanStartedEventHandler _pageTurnViewPagePanStartedEventHandler;
+  private PagePanStartedCallbackDelegate _pageTurnViewPagePanStartedCallbackDelegate;
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate void PagePanFinishedCallbackDelegate(IntPtr page);
+  private PagePanFinishedEventHandler _pageTurnViewPagePanFinishedEventHandler;
+  private PagePanFinishedCallbackDelegate _pageTurnViewPagePanFinishedCallbackDelegate;
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate void PageTurnStartedCallbackDelegate(IntPtr page, uint pageIndex, bool isTurningForward);
+  private PageTurnStartedEventHandler _pageTurnViewPageTurnStartedEventHandler;
+  private PageTurnStartedCallbackDelegate _pageTurnViewPageTurnStartedCallbackDelegate;
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate void PageTurnFinishedCallbackDelegate(IntPtr page, uint pageIndex, bool isTurningForward);
+  private PageTurnFinishedEventHandler _pageTurnViewPageTurnFinishedEventHandler;
+  private PageTurnFinishedCallbackDelegate _pageTurnViewPageTurnFinishedCallbackDelegate;
+
+  public event PagePanStartedEventHandler PagePanStarted
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_pageTurnViewPagePanStartedEventHandler == null)
+           {
+              _pageTurnViewPagePanStartedEventHandler += value;
+
+              _pageTurnViewPagePanStartedCallbackDelegate = new PagePanStartedCallbackDelegate(OnPagePanStarted);
+              this.PagePanStartedSignal().Connect(_pageTurnViewPagePanStartedCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_pageTurnViewPagePanStartedEventHandler != null)
+           {
+              this.PagePanStartedSignal().Disconnect(_pageTurnViewPagePanStartedCallbackDelegate);
+           }
+
+           _pageTurnViewPagePanStartedEventHandler -= value;
+        }
+     }
+  }
+
+  // Callback for PageTurnView PagePanStarted signal
+  private void OnPagePanStarted(IntPtr page)
+  {
+     PagePanStartedEventArgs e = new PagePanStartedEventArgs();
+
+     // Populate all members of "e" (PagePanStartedEventArgs) with real page
+     e.PageTurnView = PageTurnView.GetPageTurnViewFromPtr( page );
+
+     if (_pageTurnViewPagePanStartedEventHandler != null)
+     {
+        //here we send all page to user event handlers
+       _pageTurnViewPagePanStartedEventHandler(this, e);
+     }
+  }
+
+  public event PagePanFinishedEventHandler PagePanFinished
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_pageTurnViewPagePanFinishedEventHandler == null)
+           {
+              _pageTurnViewPagePanFinishedEventHandler += value;
+
+              _pageTurnViewPagePanFinishedCallbackDelegate = new PagePanFinishedCallbackDelegate(OnPagePanFinished);
+              this.PagePanFinishedSignal().Connect(_pageTurnViewPagePanFinishedCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_pageTurnViewPagePanFinishedEventHandler != null)
+           {
+              this.PagePanFinishedSignal().Disconnect(_pageTurnViewPagePanFinishedCallbackDelegate);
+           }
+
+           _pageTurnViewPagePanFinishedEventHandler -= value;
+        }
+     }
+  }
+
+  // Callback for PageTurnView PagePanFinished signal
+  private void OnPagePanFinished(IntPtr page)
+  {
+     PagePanFinishedEventArgs e = new PagePanFinishedEventArgs();
+
+     // Populate all members of "e" (PagePanFinishedEventArgs) with real page
+     e.PageTurnView = PageTurnView.GetPageTurnViewFromPtr( page );
+
+     if (_pageTurnViewPagePanFinishedEventHandler != null)
+     {
+        //here we send all page to user event handlers
+       _pageTurnViewPagePanFinishedEventHandler(this, e);
+     }
+  }
+
+
+  public event PageTurnStartedEventHandler PageTurnStarted
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_pageTurnViewPageTurnStartedEventHandler == null)
+           {
+              _pageTurnViewPageTurnStartedEventHandler += value;
+
+              _pageTurnViewPageTurnStartedCallbackDelegate = new PageTurnStartedCallbackDelegate(OnPageTurnStarted);
+              this.PageTurnStartedSignal().Connect(_pageTurnViewPageTurnStartedCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_pageTurnViewPageTurnStartedEventHandler != null)
+           {
+              this.PageTurnStartedSignal().Disconnect(_pageTurnViewPageTurnStartedCallbackDelegate);
+           }
+
+           _pageTurnViewPageTurnStartedEventHandler -= value;
+        }
+     }
+  }
+
+  // Callback for PageTurnView PageTurnStarted signal
+  private void OnPageTurnStarted(IntPtr page, uint pageIndex, bool isTurningForward)
+  {
+     PageTurnStartedEventArgs e = new PageTurnStartedEventArgs();
+
+     // Populate all members of "e" (PageTurnStartedEventArgs) with real page
+     e.PageTurnView = PageTurnView.GetPageTurnViewFromPtr( page );
+     e.PageIndex = pageIndex;
+     e.IsTurningForward = isTurningForward;
+
+
+     if (_pageTurnViewPageTurnStartedEventHandler != null)
+     {
+        //here we send all page to user event handlers
+       _pageTurnViewPageTurnStartedEventHandler(this, e);
+     }
+  }
+
+
+  public event PageTurnFinishedEventHandler PageTurnFinished
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_pageTurnViewPageTurnFinishedEventHandler == null)
+           {
+              _pageTurnViewPageTurnFinishedEventHandler += value;
+
+              _pageTurnViewPageTurnFinishedCallbackDelegate = new PageTurnFinishedCallbackDelegate(OnPageTurnFinished);
+              this.PageTurnFinishedSignal().Connect(_pageTurnViewPageTurnFinishedCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_pageTurnViewPageTurnFinishedEventHandler != null)
+           {
+              this.PageTurnFinishedSignal().Disconnect(_pageTurnViewPageTurnFinishedCallbackDelegate);
+           }
+
+           _pageTurnViewPageTurnFinishedEventHandler -= value;
+        }
+     }
+  }
+
+  // Callback for PageTurnView PageTurnFinished signal
+  private void OnPageTurnFinished(IntPtr page, uint pageIndex, bool isTurningForward)
+  {
+     PageTurnFinishedEventArgs e = new PageTurnFinishedEventArgs();
+
+     // Populate all members of "e" (PageTurnFinishedEventArgs) with real page
+     e.PageTurnView = PageTurnView.GetPageTurnViewFromPtr( page );
+     e.PageIndex = pageIndex;
+     e.IsTurningForward = isTurningForward;
+
+
+     if (_pageTurnViewPageTurnFinishedEventHandler != null)
+     {
+        //here we send all page to user event handlers
+       _pageTurnViewPageTurnFinishedEventHandler(this, e);
+     }
+  }
+
+  public static ClassName Get ## ClassName ## FromPtr(global::System.IntPtr cPtr) {
+    ClassName ret = new ClassName(cPtr, false);
+   if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+    return ret;
+  }
+
+%}
+
+%enddef
+
+
+%define DALI_PAGETURNVIEW_EVENTHANDLER_PARAM( NameSpace, ClassName)
+
+  PAGETURNVIEW_EVENTHANDLER_TYPEMAP_EVENTARG( NameSpace, ClassName);
+  PAGETURNVIEW_EVENTHANDLER_TYPEMAP_HELPER( NameSpace, ClassName);
+
+%enddef
+
+namespace Dali
+{
+  DALI_PAGETURNVIEW_EVENTHANDLER_PARAM( Dali::Toolkit, PageTurnView);
+}
diff --git a/plugins/dali-swig/SWIG/events/pangesture-event.i b/plugins/dali-swig/SWIG/events/pangesture-event.i
new file mode 100644 (file)
index 0000000..db32481
--- /dev/null
@@ -0,0 +1,138 @@
+/*
+ * Copyright (c) 2016 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.
+ *
+ */
+
+%define PANGESTURE_EVENTHANDLER_TYPEMAP_EVENTARG(NameSpace, ClassName)
+%typemap(csimports) NameSpace::ClassName %{
+using System;
+using System.Runtime.InteropServices;
+
+%}
+
+%enddef
+
+%define PANGESTURE_EVENTHANDLER_TYPEMAP_HELPER(NameSpace, ClassName)
+%typemap(cscode) NameSpace::ClassName %{
+
+
+public class DetectedEventArgs : EventArgs
+{
+   private Actor _actor;
+   private PanGesture _panGesture;
+
+   public Actor Actor
+   {
+      get
+      {
+         return _actor;
+      }
+      set
+      {
+         _actor = value;
+      }
+   }
+
+   public PanGesture PanGesture
+   {
+      get
+      {
+         return _panGesture;
+      }
+      set
+      {
+         _panGesture = value;
+      }
+   }
+}
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate void DetectedEventHandler(object source, DetectedEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate void DetectedCallbackDelegate(IntPtr actor, IntPtr panGesture);
+  private DetectedEventHandler _panGestureEventHandler;
+  private DetectedCallbackDelegate _panGestureCallbackDelegate;
+
+
+  public event DetectedEventHandler Detected
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_panGestureEventHandler == null)
+           {
+              _panGestureEventHandler += value;
+
+              _panGestureCallbackDelegate = new DetectedCallbackDelegate(OnPanGestureDetected);
+              this.DetectedSignal().Connect(_panGestureCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_panGestureEventHandler != null)
+           {
+              this.DetectedSignal().Disconnect(_panGestureCallbackDelegate);
+           }
+
+           _panGestureEventHandler -= value;
+        }
+     }
+  }
+
+ private void OnPanGestureDetected(IntPtr actor, IntPtr panGesture)
+  {
+   DetectedEventArgs e = new DetectedEventArgs();
+
+   // Populate all members of "e" (PanGestureEventArgs) with real data
+   e.Actor = Actor.GetActorFromPtr(actor);
+   e.PanGesture = Dali.PanGesture.GetPanGestureFromPtr(panGesture);
+
+   if (_panGestureEventHandler != null)
+   {
+      //here we send all data to user event handlers
+      _panGestureEventHandler(this, e);
+   }
+
+  }
+
+
+public static ClassName Get ## ClassName ## FromPtr(global::System.IntPtr cPtr) {
+    ClassName ret = new ClassName(cPtr, false);
+   if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+    return ret;
+  }
+
+%}
+
+%enddef
+
+%define DALI_PANGESTURE_EVENTHANDLER_PARAM( NameSpace, ClassName)
+
+  PANGESTURE_EVENTHANDLER_TYPEMAP_EVENTARG( NameSpace, ClassName);
+  PANGESTURE_EVENTHANDLER_TYPEMAP_HELPER( NameSpace, ClassName);
+
+%enddef
+
+namespace Dali
+{
+  DALI_PANGESTURE_EVENTHANDLER_PARAM( Dali, PanGestureDetector);
+}
diff --git a/plugins/dali-swig/SWIG/events/pinchgesture-event.i b/plugins/dali-swig/SWIG/events/pinchgesture-event.i
new file mode 100644 (file)
index 0000000..abdcced
--- /dev/null
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) 2016 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.
+ *
+ */
+
+%define PINCHGESTURE_EVENTHANDLER_TYPEMAP_EVENTARG(NameSpace, ClassName)
+%typemap(csimports) NameSpace::ClassName %{
+using System;
+using System.Runtime.InteropServices;
+
+%}
+
+%enddef
+
+%define PINCHGESTURE_EVENTHANDLER_TYPEMAP_HELPER(NameSpace, ClassName)
+%typemap(cscode) NameSpace::ClassName %{
+
+public class DetectedEventArgs : EventArgs
+{
+   private Actor _actor;
+   private PinchGesture _pinchGesture;
+
+   public Actor Actor
+   {
+      get
+      {
+         return _actor;
+      }
+      set
+      {
+         _actor = value;
+      }
+   }
+
+   public PinchGesture PinchGesture
+   {
+      get
+      {
+         return _pinchGesture;
+      }
+      set
+      {
+         _pinchGesture = value;
+      }
+   }
+}
+
+[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+public delegate void DetectedEventHandler(object source, DetectedEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate void DetectedCallbackDelegate(IntPtr actor, IntPtr pinchGesture);
+  private DetectedEventHandler _pinchGestureEventHandler;
+  private DetectedCallbackDelegate _pinchGestureCallbackDelegate;
+
+
+  public event DetectedEventHandler Detected
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_pinchGestureEventHandler == null)
+           {
+              _pinchGestureEventHandler += value;
+
+              _pinchGestureCallbackDelegate = new DetectedCallbackDelegate(OnPinchGestureDetected);
+              this.DetectedSignal().Connect(_pinchGestureCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_pinchGestureEventHandler != null)
+           {
+              this.DetectedSignal().Disconnect(_pinchGestureCallbackDelegate);
+           }
+
+           _pinchGestureEventHandler -= value;
+        }
+     }
+  }
+
+ private void OnPinchGestureDetected(IntPtr actor, IntPtr pinchGesture)
+  {
+   DetectedEventArgs e = new DetectedEventArgs();
+
+   // Populate all members of "e" (DetectedEventArgs) with real data
+   e.Actor = Actor.GetActorFromPtr(actor);
+   e.PinchGesture = Dali.PinchGesture.GetPinchGestureFromPtr(pinchGesture);
+
+   if (_pinchGestureEventHandler != null)
+   {
+      //here we send all data to user event handlers
+      _pinchGestureEventHandler(this, e);
+   }
+
+  }
+
+
+public static ClassName Get ## ClassName ## FromPtr(global::System.IntPtr cPtr) {
+    ClassName ret = new ClassName(cPtr, false);
+   if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+    return ret;
+  }
+
+%}
+
+%enddef
+
+%define DALI_PINCHGESTURE_EVENTHANDLER_PARAM( NameSpace, ClassName)
+
+  PINCHGESTURE_EVENTHANDLER_TYPEMAP_EVENTARG( NameSpace, ClassName);
+  PINCHGESTURE_EVENTHANDLER_TYPEMAP_HELPER( NameSpace, ClassName);
+
+%enddef
+
+namespace Dali
+{
+  DALI_PINCHGESTURE_EVENTHANDLER_PARAM( Dali, PinchGestureDetector);
+}
diff --git a/plugins/dali-swig/SWIG/events/popup-event.i b/plugins/dali-swig/SWIG/events/popup-event.i
new file mode 100644 (file)
index 0000000..cc819cf
--- /dev/null
@@ -0,0 +1,318 @@
+/*
+ * Copyright (c) 2016 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.
+ *
+ */
+
+%define POPUP_EVENTHANDLER_TYPEMAP_EVENTARG(NameSpace, ClassName)
+%typemap(csimports) NameSpace::ClassName %{
+using System;
+using System.Runtime.InteropServices;
+
+%}
+
+%enddef
+
+
+%define POPUP_EVENTHANDLER_TYPEMAP_HELPER(NameSpace, ClassName)
+%typemap(cscode) NameSpace::ClassName %{
+
+  public class OutsideTouchedEventArgs : EventArgs
+  {
+  }
+
+  public class ShowingEventArgs : EventArgs
+  {
+  }
+
+  public class ShownEventArgs : EventArgs
+  {
+  }
+
+  public class HidingEventArgs : EventArgs
+  {
+  }
+
+  public class HiddenEventArgs : EventArgs
+  {
+  }
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate void OutsideTouchedEventHandler(object source, OutsideTouchedEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate void ShowingEventHandler(object source, ShowingEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate void ShownEventHandler(object source, ShownEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate void HidingEventHandler(object source, HidingEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate void HiddenEventHandler(object source, HiddenEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate void OutsideTouchedEventCallbackDelegate();
+  private OutsideTouchedEventHandler _popUpOutsideTouchedEventHandler;
+  private OutsideTouchedEventCallbackDelegate _popUpOutsideTouchedEventCallbackDelegate;
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate void ShowingEventCallbackDelegate();
+  private ShowingEventHandler _popUpShowingEventHandler;
+  private ShowingEventCallbackDelegate _popUpShowingEventCallbackDelegate;
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate void ShownEventCallbackDelegate();
+  private ShownEventHandler _popUpShownEventHandler;
+  private ShownEventCallbackDelegate _popUpShownEventCallbackDelegate;
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate void HidingEventCallbackDelegate();
+  private HidingEventHandler _popUpHidingEventHandler;
+  private HidingEventCallbackDelegate _popUpHidingEventCallbackDelegate;
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate void HiddenEventCallbackDelegate();
+  private HiddenEventHandler _popUpHiddenEventHandler;
+  private HiddenEventCallbackDelegate _popUpHiddenEventCallbackDelegate;
+
+  public event OutsideTouchedEventHandler OutsideTouched
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_popUpOutsideTouchedEventHandler == null)
+           {
+              _popUpOutsideTouchedEventHandler += value;
+
+              _popUpOutsideTouchedEventCallbackDelegate = new OutsideTouchedEventCallbackDelegate(OnOutsideTouched);
+              this.OutsideTouchedSignal().Connect(_popUpOutsideTouchedEventCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_popUpOutsideTouchedEventHandler != null)
+           {
+              this.OutsideTouchedSignal().Disconnect(_popUpOutsideTouchedEventCallbackDelegate);
+           }
+
+           _popUpOutsideTouchedEventHandler -= value;
+        }
+     }
+  }
+
+  // Callback for Popup OutsideTouchedSignal
+  private void OnOutsideTouched()
+  {
+     OutsideTouchedEventArgs e = new OutsideTouchedEventArgs();
+
+     if (_popUpOutsideTouchedEventHandler != null)
+     {
+        //here we send all data to user event handlers
+        _popUpOutsideTouchedEventHandler(this, e);
+     }
+  }
+
+  public event ShowingEventHandler Showing
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_popUpShowingEventHandler == null)
+           {
+              _popUpShowingEventHandler += value;
+
+              _popUpShowingEventCallbackDelegate = new ShowingEventCallbackDelegate(OnShowing);
+              this.ShowingSignal().Connect(_popUpShowingEventCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_popUpShowingEventHandler != null)
+           {
+              this.ShowingSignal().Disconnect(_popUpShowingEventCallbackDelegate);
+           }
+
+           _popUpShowingEventHandler -= value;
+        }
+     }
+  }
+
+  // Callback for ShowingSignal
+  private void OnShowing()
+  {
+     ShowingEventArgs e = new ShowingEventArgs();
+
+     if (_popUpShowingEventHandler != null)
+     {
+        //here we send all data to user event handlers
+        _popUpShowingEventHandler(this, e);
+     }
+  }
+
+
+  public event ShownEventHandler Shown
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_popUpShownEventHandler == null)
+           {
+              _popUpShownEventHandler += value;
+
+              _popUpShownEventCallbackDelegate = new ShownEventCallbackDelegate(OnShown);
+              this.ShownSignal().Connect(_popUpShownEventCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_popUpShownEventHandler != null)
+           {
+              this.ShownSignal().Disconnect(_popUpShownEventCallbackDelegate);
+           }
+
+           _popUpShownEventHandler -= value;
+        }
+     }
+  }
+
+  // Callback for ShownSignal
+  private void OnShown()
+  {
+     ShownEventArgs e = new ShownEventArgs();
+
+     if (_popUpShownEventHandler != null)
+     {
+        //here we send all data to user event handlers
+        _popUpShownEventHandler(this, e);
+     }
+  }
+
+  public event HidingEventHandler Hiding
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_popUpHidingEventHandler == null)
+           {
+              _popUpHidingEventHandler += value;
+
+              _popUpHidingEventCallbackDelegate = new HidingEventCallbackDelegate(OnHiding);
+              this.HidingSignal().Connect(_popUpHidingEventCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_popUpHidingEventHandler != null)
+           {
+              this.HidingSignal().Disconnect(_popUpHidingEventCallbackDelegate);
+           }
+
+           _popUpHidingEventHandler -= value;
+        }
+     }
+  }
+
+  // Callback for HidingSignal
+  private void OnHiding()
+  {
+     HidingEventArgs e = new HidingEventArgs();
+
+     if (_popUpHidingEventHandler != null)
+     {
+        //here we send all data to user event handlers
+        _popUpHidingEventHandler(this, e);
+     }
+  }
+
+  public event HiddenEventHandler Hidden
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_popUpHiddenEventHandler == null)
+           {
+              _popUpHiddenEventHandler += value;
+
+              _popUpHiddenEventCallbackDelegate = new HiddenEventCallbackDelegate(OnHidden);
+              this.HiddenSignal().Connect(_popUpHiddenEventCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_popUpHiddenEventHandler != null)
+           {
+              this.HiddenSignal().Disconnect(_popUpHiddenEventCallbackDelegate);
+           }
+
+           _popUpHiddenEventHandler -= value;
+        }
+     }
+  }
+
+  // Callback for HiddenSignal
+  private void OnHidden()
+  {
+     HiddenEventArgs e = new HiddenEventArgs();
+
+     if (_popUpHiddenEventHandler != null)
+     {
+        //here we send all data to user event handlers
+        _popUpHiddenEventHandler(this, e);
+     }
+  }
+%}
+%enddef
+
+%define DALI_POPUP_EVENTHANDLER_PARAM( NameSpace, ClassName)
+  POPUP_EVENTHANDLER_TYPEMAP_EVENTARG( NameSpace, ClassName);
+  POPUP_EVENTHANDLER_TYPEMAP_HELPER( NameSpace, ClassName);
+%enddef
+
+namespace Dali
+{
+  DALI_POPUP_EVENTHANDLER_PARAM( Dali::Toolkit, Popup);
+}
+
diff --git a/plugins/dali-swig/SWIG/events/propertynotification-event.i b/plugins/dali-swig/SWIG/events/propertynotification-event.i
new file mode 100644 (file)
index 0000000..17bce47
--- /dev/null
@@ -0,0 +1,131 @@
+/*
+ * Copyright (c) 2016 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.
+ *
+ */
+
+%define PROPERTYNOTIFICATION_EVENTHANDLER_TYPEMAP_EVENTARG(NameSpace, ClassName)
+%typemap(csimports) NameSpace::ClassName %{
+using System;
+using System.Runtime.InteropServices;
+
+%}
+
+%enddef
+
+
+%define PROPERTYNOTIFICATION_EVENTHANDLER_TYPEMAP_HELPER(NameSpace, ClassName)
+%typemap(cscode) NameSpace::ClassName %{
+
+/**
+  * @brief Event arguments that passed via Notify signal
+  *
+  */
+public class NotifyEventArgs : EventArgs
+{
+   private PropertyNotification _propertyNotification;
+
+   /**
+     * @brief PropertyNotification - is the PropertyNotification handle that has the notification properties.
+     *
+     */
+   public PropertyNotification PropertyNotification
+   {
+      get
+      {
+         return _propertyNotification;
+      }
+      set
+      {
+         _propertyNotification = value;
+      }
+   }
+}
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate void NotifyEventHandler(object source, NotifyEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate void NotifyEventCallbackDelegate(IntPtr propertyNotification);
+  private NotifyEventHandler _propertyNotificationNotifyEventHandler;
+  private NotifyEventCallbackDelegate _propertyNotificationNotifyEventCallbackDelegate;
+
+  /**
+    * @brief Event for Notified signal which can be used to subscribe/unsubscribe the event handler
+    * (in the type of NotifyEventHandler) provided by the user.
+    * Notified signal is emitted when the notification upon a condition of the property being met, has occurred.
+    */
+  public event NotifyEventHandler Notified
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_propertyNotificationNotifyEventHandler == null)
+           {
+              _propertyNotificationNotifyEventHandler += value;
+
+              _propertyNotificationNotifyEventCallbackDelegate = new NotifyEventCallbackDelegate(OnPropertyNotificationNotify);
+              this.NotifySignal().Connect(_propertyNotificationNotifyEventCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_propertyNotificationNotifyEventHandler != null)
+           {
+              this.NotifySignal().Disconnect(_propertyNotificationNotifyEventCallbackDelegate);
+           }
+
+           _propertyNotificationNotifyEventHandler -= value;
+        }
+     }
+  }
+
+  // Callback for PropertyNotification NotifySignal
+  private void OnPropertyNotificationNotify(IntPtr propertyNotification)
+  {
+     NotifyEventArgs e = new NotifyEventArgs();
+     e.PropertyNotification  = GetPropertyNotificationFromPtr(propertyNotification);
+
+     if (_propertyNotificationNotifyEventHandler != null)
+     {
+        //here we send all data to user event handlers
+        _propertyNotificationNotifyEventHandler(this, e);
+     }
+  }
+
+  public static ClassName Get ## ClassName ## FromPtr(global::System.IntPtr cPtr) {
+    ClassName ret = new ClassName(cPtr, false);
+   if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+    return ret;
+  }
+
+%}
+%enddef
+
+%define DALI_PROPERTYNOTIFICATION_EVENTHANDLER_PARAM( NameSpace, ClassName)
+  PROPERTYNOTIFICATION_EVENTHANDLER_TYPEMAP_EVENTARG( NameSpace, ClassName);
+  PROPERTYNOTIFICATION_EVENTHANDLER_TYPEMAP_HELPER( NameSpace, ClassName);
+%enddef
+
+namespace Dali
+{
+  DALI_PROPERTYNOTIFICATION_EVENTHANDLER_PARAM( Dali, PropertyNotification);
+}
+
diff --git a/plugins/dali-swig/SWIG/events/rendertask-event.i b/plugins/dali-swig/SWIG/events/rendertask-event.i
new file mode 100644 (file)
index 0000000..729e8a3
--- /dev/null
@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) 2016 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.
+ *
+ */
+
+%define RenderTask_EVENTHANDLER_TYPEMAP_EVENTARG(NameSpace, ClassName)
+%typemap(csimports) NameSpace::ClassName %{
+using System;
+using System.Runtime.InteropServices;
+
+%}
+
+%enddef
+
+%define RenderTask_EVENTHANDLER_TYPEMAP_HELPER(NameSpace, ClassName)
+%typemap(cscode) NameSpace::ClassName %{
+
+
+public class FinishedEventArgs : EventArgs
+{
+   private RenderTask _renderTask;
+
+   public RenderTask RenderTask
+   {
+      get
+      {
+         return _renderTask;
+      }
+      set
+      {
+         _renderTask = value;
+      }
+   }
+}
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate void RenderTaskEventHandler(object source, FinishedEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate void RenderTaskCallbackDelegate(IntPtr renderTask);
+  private RenderTaskEventHandler _renderTaskEventHandler;
+  private RenderTaskCallbackDelegate _renderTaskCallbackDelegate;
+
+
+  public event RenderTaskEventHandler Finished
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_renderTaskEventHandler == null)
+           {
+              _renderTaskEventHandler += value;
+
+              _renderTaskCallbackDelegate = new RenderTaskCallbackDelegate(OnFinished);
+              this.FinishedSignal().Connect(_renderTaskCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_renderTaskEventHandler != null)
+           {
+              this.FinishedSignal().Disconnect(_renderTaskCallbackDelegate);
+           }
+
+           _renderTaskEventHandler -= value;
+        }
+     }
+  }
+
+ private void OnFinished(IntPtr actor, IntPtr renderTask)
+  {
+   FinishedEventArgs e = new FinishedEventArgs();
+
+   // Populate all members of "e" (FinishedEventArgs) with real data
+   e.RenderTask = Dali.RenderTask.GetRenderTaskFromPtr(renderTask);
+
+   if (_renderTaskEventHandler != null)
+   {
+      //here we send all data to user event handlers
+      _renderTaskEventHandler(this, e);
+   }
+
+  }
+
+
+public static ClassName Get ## ClassName ## FromPtr(global::System.IntPtr cPtr) {
+   ClassName ret = new ClassName(cPtr, false);
+   if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+    return ret;
+  }
+
+%}
+
+%enddef
+
+%define DALI_renderTask_EVENTHANDLER_PARAM( NameSpace, ClassName)
+
+  RenderTask_EVENTHANDLER_TYPEMAP_EVENTARG( NameSpace, ClassName);
+  RenderTask_EVENTHANDLER_TYPEMAP_HELPER( NameSpace, ClassName);
+
+%enddef
+
+namespace Dali
+{
+  DALI_renderTask_EVENTHANDLER_PARAM( Dali, RenderTask);
+}
diff --git a/plugins/dali-swig/SWIG/events/resourceimage-event.i b/plugins/dali-swig/SWIG/events/resourceimage-event.i
new file mode 100644 (file)
index 0000000..aa601eb
--- /dev/null
@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) 2016 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.
+ *
+ */
+
+%define ResourceImage_EVENTHANDLER_TYPEMAP_EVENTARG(NameSpace, ClassName)
+%typemap(csimports) NameSpace::ClassName %{
+using System;
+using System.Runtime.InteropServices;
+
+%}
+%enddef
+
+%define ResourceImage_EVENTHANDLER_TYPEMAP_HELPER(NameSpace, ClassName)
+%typemap(cscode) NameSpace::ClassName %{
+
+public class LoadingFinishedEventArgs : EventArgs
+{
+   private ResourceImage _resourceImage;
+
+   public ResourceImage ResourceImage
+   {
+      get
+      {
+         return _resourceImage;
+      }
+      set
+      {
+         _resourceImage = value;
+      }
+   }
+}
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate void LoadingFinishedEventHandler(object source, LoadingFinishedEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate void LoadingFinishedEventCallbackDelegate(IntPtr ResourceImage);
+  private LoadingFinishedEventHandler _resourceImageLoadingFinishedEventHandler;
+  private LoadingFinishedEventCallbackDelegate _resourceImageLoadingFinishedEventCallbackDelegate;
+
+  public event LoadingFinishedEventHandler LoadingFinished
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_resourceImageLoadingFinishedEventHandler == null)
+           {
+              _resourceImageLoadingFinishedEventHandler += value;
+
+              _resourceImageLoadingFinishedEventCallbackDelegate = new LoadingFinishedEventCallbackDelegate(OnLoadingFinished);
+              this.LoadingFinishedSignal().Connect(_resourceImageLoadingFinishedEventCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_resourceImageLoadingFinishedEventHandler != null)
+           {
+              this.LoadingFinishedSignal().Disconnect(_resourceImageLoadingFinishedEventCallbackDelegate);
+           }
+
+           _resourceImageLoadingFinishedEventHandler -= value;
+        }
+     }
+  }
+
+  // Callback for ResourceImage LoadingFinishedSignal
+  private void OnLoadingFinished(IntPtr data)
+  {
+     LoadingFinishedEventArgs e = new LoadingFinishedEventArgs();
+
+     // Populate all members of "e" (LoadingFinishedEventArgs) with real data
+     e.ResourceImage = ResourceImage.GetResourceImageFromPtr(data);
+
+     if (_resourceImageLoadingFinishedEventHandler != null)
+     {
+        //here we send all data to user event handlers
+        _resourceImageLoadingFinishedEventHandler(this, e);
+     }
+  }
+
+
+public static ClassName Get ## ClassName ## FromPtr(global::System.IntPtr cPtr) {
+    ClassName ret = new ClassName(cPtr, false);
+   if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+    return ret;
+  }
+
+%}
+
+%enddef
+
+
+%define DALI_resourceImage_EVENTHANDLER_PARAM( NameSpace, ClassName)
+  ResourceImage_EVENTHANDLER_TYPEMAP_EVENTARG( NameSpace, ClassName);
+  ResourceImage_EVENTHANDLER_TYPEMAP_HELPER( NameSpace, ClassName);
+%enddef
+
+namespace Dali
+{
+  DALI_resourceImage_EVENTHANDLER_PARAM( Dali, ResourceImage);
+}
diff --git a/plugins/dali-swig/SWIG/events/scrollable-event.i b/plugins/dali-swig/SWIG/events/scrollable-event.i
new file mode 100644 (file)
index 0000000..1ab5d13
--- /dev/null
@@ -0,0 +1,256 @@
+/*
+ * Copyright (c) 2016 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.
+ *
+ */
+
+%define SCROLLABLE_EVENTHANDLER_TYPEMAP_EVENTARG(NameSpace, ClassName)
+%typemap(csimports) NameSpace::ClassName %{
+using System;
+using System.Runtime.InteropServices;
+
+%}
+%enddef
+
+%define SCROLLABLE_EVENTHANDLER_TYPEMAP_HELPER(NameSpace, ClassName)
+%typemap(cscode) NameSpace::ClassName %{
+
+public class StartedEventArgs : EventArgs
+{
+   private Vector2 _vector2;
+
+   public Vector2 Vector2
+   {
+      get
+      {
+         return _vector2;
+      }
+      set
+      {
+         _vector2 = value;
+      }
+   }
+}
+
+public class UpdatedEventArgs : EventArgs
+{
+   private Vector2 _vector2;
+
+   public Vector2 Vector2
+   {
+      get
+      {
+         return _vector2;
+      }
+      set
+      {
+         _vector2 = value;
+      }
+   }
+}
+
+public class CompletedEventArgs : EventArgs
+{
+   private Vector2 _vector2;
+
+   public Vector2 Vector2
+   {
+      get
+      {
+         return _vector2;
+      }
+      set
+      {
+         _vector2 = value;
+      }
+   }
+}
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate void StartedEventHandler(object source, StartedEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate void UpdatedEventHandler(object source, UpdatedEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate void CompletedEventHandler(object source, CompletedEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate void StartedCallbackDelegate(IntPtr vector2);
+  private StartedEventHandler _scrollableStartedEventHandler;
+  private StartedCallbackDelegate _scrollableStartedCallbackDelegate;
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate void UpdatedCallbackDelegate(IntPtr vector2);
+  private UpdatedEventHandler _scrollableUpdatedEventHandler;
+  private UpdatedCallbackDelegate _scrollableUpdatedCallbackDelegate;
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate void CompletedCallbackDelegate(IntPtr vector2);
+  private CompletedEventHandler _scrollableCompletedEventHandler;
+  private CompletedCallbackDelegate _scrollableCompletedCallbackDelegate;
+
+  public event StartedEventHandler ScrollStarted
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_scrollableStartedEventHandler == null)
+           {
+              _scrollableStartedEventHandler += value;
+
+              _scrollableStartedCallbackDelegate = new StartedCallbackDelegate(OnStarted);
+              this.ScrollStartedSignal().Connect(_scrollableStartedCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_scrollableStartedEventHandler != null)
+           {
+              this.ScrollStartedSignal().Disconnect(_scrollableStartedCallbackDelegate);
+           }
+
+           _scrollableStartedEventHandler -= value;
+        }
+     }
+  }
+
+ private void OnStarted(IntPtr vector2)
+  {
+   StartedEventArgs e = new StartedEventArgs();
+
+   // Populate all members of "e" (StartedEventArgs) with real data
+   e.Vector2 = Dali.Vector2.GetVector2FromPtr(vector2);
+
+   if (_scrollableStartedEventHandler != null)
+   {
+      //here we send all data to user event handlers
+      _scrollableStartedEventHandler(this, e);
+   }
+
+  }
+
+  public event UpdatedEventHandler ScrollUpdated
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_scrollableUpdatedEventHandler == null)
+           {
+              _scrollableUpdatedEventHandler += value;
+
+              _scrollableUpdatedCallbackDelegate = new UpdatedCallbackDelegate(OnUpdated);
+              this.ScrollUpdatedSignal().Connect(_scrollableUpdatedCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_scrollableUpdatedEventHandler != null)
+           {
+              this.ScrollUpdatedSignal().Disconnect(_scrollableUpdatedCallbackDelegate);
+           }
+
+           _scrollableUpdatedEventHandler -= value;
+        }
+     }
+  }
+
+ private void OnUpdated(IntPtr vector2)
+  {
+   UpdatedEventArgs e = new UpdatedEventArgs();
+
+   // Populate all members of "e" (UpdatedEventArgs) with real data
+   e.Vector2 = Dali.Vector2.GetVector2FromPtr(vector2);
+
+   if (_scrollableUpdatedEventHandler != null)
+   {
+      //here we send all data to user event handlers
+      _scrollableUpdatedEventHandler(this, e);
+   }
+
+  }
+
+  public event CompletedEventHandler ScrollCompleted
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_scrollableCompletedEventHandler == null)
+           {
+              _scrollableCompletedEventHandler += value;
+
+              _scrollableCompletedCallbackDelegate = new CompletedCallbackDelegate(OnCompleted);
+              this.ScrollCompletedSignal().Connect(_scrollableCompletedCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_scrollableCompletedEventHandler != null)
+           {
+              this.ScrollCompletedSignal().Disconnect(_scrollableCompletedCallbackDelegate);
+           }
+
+           _scrollableCompletedEventHandler -= value;
+        }
+     }
+  }
+
+ private void OnCompleted(IntPtr vector2)
+  {
+   CompletedEventArgs e = new CompletedEventArgs();
+
+   // Populate all members of "e" (CompletedEventArgs) with real data
+   e.Vector2 = Dali.Vector2.GetVector2FromPtr(vector2);
+
+   if (_scrollableCompletedEventHandler != null)
+   {
+      //here we send all data to user event handlers
+      _scrollableCompletedEventHandler(this, e);
+   }
+
+  }
+
+%}
+
+%enddef
+
+%define DALI_SCROLLABLE_EVENTHANDLER_PARAM( NameSpace, ClassName)
+
+  SCROLLABLE_EVENTHANDLER_TYPEMAP_EVENTARG( NameSpace, ClassName);
+  SCROLLABLE_EVENTHANDLER_TYPEMAP_HELPER( NameSpace, ClassName);
+
+%enddef
+
+namespace Dali
+{
+  DALI_SCROLLABLE_EVENTHANDLER_PARAM( Dali::Toolkit, Scrollable);
+}
diff --git a/plugins/dali-swig/SWIG/events/scrollbar-event.i b/plugins/dali-swig/SWIG/events/scrollbar-event.i
new file mode 100644 (file)
index 0000000..256be79
--- /dev/null
@@ -0,0 +1,168 @@
+/*
+ * Copyright (c) 2016 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.
+ *
+ */
+
+%define SCROLLBAR_EVENTHANDLER_TYPEMAP_EVENTARG(NameSpace, ClassName)
+%typemap(csimports) NameSpace::ClassName %{
+using System;
+using System.Runtime.InteropServices;
+
+%}
+
+%enddef
+
+
+%define SCROLLBAR_EVENTHANDLER_TYPEMAP_HELPER(NameSpace, ClassName)
+%typemap(cscode) NameSpace::ClassName %{
+
+
+public class PanFinishedEventArgs : EventArgs
+{
+}
+
+public class ScrollPositionIntervalReachedEventArgs : EventArgs
+{
+   private float _currentScrollPosition;
+
+   public float CurrentScrollPosition
+   {
+      get
+      {
+         return _currentScrollPosition;
+      }
+      set
+      {
+         _currentScrollPosition = value;
+      }
+   }
+}
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate void PanFinishedEventHandler(object source, PanFinishedEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate void ScrollPositionIntervalReachedEventHandler(object source, ScrollPositionIntervalReachedEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate void PanFinishedEventCallbackDelegate();
+  private PanFinishedEventHandler _scrollBarPanFinishedEventHandler;
+  private PanFinishedEventCallbackDelegate _scrollBarPanFinishedEventCallbackDelegate;
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate void ScrollPositionIntervalReachedEventCallbackDelegate();
+  private ScrollPositionIntervalReachedEventHandler _scrollBarScrollPositionIntervalReachedEventHandler;
+  private ScrollPositionIntervalReachedEventCallbackDelegate _scrollBarScrollPositionIntervalReachedEventCallbackDelegate;
+
+  public event PanFinishedEventHandler PanFinished
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_scrollBarPanFinishedEventHandler == null)
+           {
+              _scrollBarPanFinishedEventHandler += value;
+
+              _scrollBarPanFinishedEventCallbackDelegate = new PanFinishedEventCallbackDelegate(OnScrollBarPanFinished);
+              this.PanFinishedSignal().Connect(_scrollBarPanFinishedEventCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_scrollBarPanFinishedEventHandler != null)
+           {
+              this.PanFinishedSignal().Disconnect(_scrollBarPanFinishedEventCallbackDelegate);
+           }
+
+           _scrollBarPanFinishedEventHandler -= value;
+        }
+     }
+  }
+
+  // Callback for ScrollBar PanFinishedSignal
+  private void OnScrollBarPanFinished()
+  {
+     PanFinishedEventArgs e = new PanFinishedEventArgs();
+
+     if (_scrollBarPanFinishedEventHandler != null)
+     {
+        //here we send all data to user event handlers
+        _scrollBarPanFinishedEventHandler(this, e);
+     }
+  }
+
+
+  public event ScrollPositionIntervalReachedEventHandler ScrollPositionIntervalReached
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_scrollBarScrollPositionIntervalReachedEventHandler == null)
+           {
+              _scrollBarScrollPositionIntervalReachedEventHandler += value;
+
+              _scrollBarScrollPositionIntervalReachedEventCallbackDelegate = new ScrollPositionIntervalReachedEventCallbackDelegate(OnScrollBarScrollPositionIntervalReached);
+              this.ScrollPositionIntervalReachedSignal().Connect(_scrollBarScrollPositionIntervalReachedEventCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_scrollBarScrollPositionIntervalReachedEventHandler != null)
+           {
+              this.ScrollPositionIntervalReachedSignal().Disconnect(_scrollBarScrollPositionIntervalReachedEventCallbackDelegate);
+           }
+
+           _scrollBarScrollPositionIntervalReachedEventHandler -= value;
+        }
+     }
+  }
+
+  // Callback for ScrollBar ScrollPositionIntervalReachedSignal
+  private void OnScrollBarScrollPositionIntervalReached()
+  {
+     ScrollPositionIntervalReachedEventArgs e = new ScrollPositionIntervalReachedEventArgs();
+
+     if (_scrollBarScrollPositionIntervalReachedEventHandler != null)
+     {
+        //here we send all data to user event handlers
+        _scrollBarScrollPositionIntervalReachedEventHandler(this, e);
+     }
+  }
+
+%}
+%enddef
+
+%define DALI_SCROLLBAR_EVENTHANDLER_PARAM( NameSpace, ClassName)
+  SCROLLBAR_EVENTHANDLER_TYPEMAP_EVENTARG( NameSpace, ClassName);
+  SCROLLBAR_EVENTHANDLER_TYPEMAP_HELPER( NameSpace, ClassName);
+%enddef
+
+namespace Dali
+{
+  DALI_SCROLLBAR_EVENTHANDLER_PARAM( Dali::Toolkit, ScrollBar);
+}
+
diff --git a/plugins/dali-swig/SWIG/events/scrollview-event.i b/plugins/dali-swig/SWIG/events/scrollview-event.i
new file mode 100644 (file)
index 0000000..733a502
--- /dev/null
@@ -0,0 +1,131 @@
+/*
+ * Copyright (c) 2016 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.
+ *
+ */
+
+%define SCROLLVIEW_EVENTHANDLER_TYPEMAP_EVENTARG(NameSpace, ClassName)
+%typemap(csimports) NameSpace::ClassName %{
+using System;
+using System.Runtime.InteropServices;
+
+%}
+%enddef
+
+%define SCROLLVIEW_EVENTHANDLER_TYPEMAP_HELPER(NameSpace, ClassName)
+%typemap(cscode) NameSpace::ClassName %{
+
+/**
+  * @brief Event arguments that passed via SnapStarted signal
+  *
+  */
+public class SnapStartedEventArgs : EventArgs
+{
+   private Dali.ScrollView.SnapEvent _snapEvent;
+
+   /**
+     * @brief SnapEvent - is the SnapEvent information like snap or flick (it tells the target position, scale, rotation for the snap or flick).
+     *
+     */
+   public Dali.ScrollView.SnapEvent SnapEventInfo
+   {
+      get
+      {
+         return _snapEvent;
+      }
+      set
+      {
+         _snapEvent = value;
+      }
+   }
+}
+
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate void SnapStartedEventHandler(object source, SnapStartedEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate void SnapStartedCallbackDelegate(IntPtr data);
+  private SnapStartedEventHandler _scrollViewSnapStartedEventHandler;
+  private SnapStartedCallbackDelegate _scrollViewSnapStartedCallbackDelegate;
+
+  /**
+    * @brief Event for SnapStarted signal which can be used to subscribe/unsubscribe the event handler
+    * (in the type of SnapStartedEventHandler) provided by the user.
+    * SnapStarted signal is emitted hen the ScrollView has started to snap or flick (it tells the target
+    * position, scale, rotation for the snap or flick).
+    *
+    */
+ public event SnapStartedEventHandler SnapStarted
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_scrollViewSnapStartedEventHandler == null)
+           {
+              _scrollViewSnapStartedEventHandler += value;
+
+              _scrollViewSnapStartedCallbackDelegate = new SnapStartedCallbackDelegate(OnSnapStarted);
+              this.SnapStartedSignal().Connect(_scrollViewSnapStartedCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_scrollViewSnapStartedEventHandler != null)
+           {
+              this.SnapStartedSignal().Disconnect(_scrollViewSnapStartedCallbackDelegate);
+           }
+
+           _scrollViewSnapStartedEventHandler -= value;
+        }
+     }
+  }
+
+  // Callback for ScrollView SnapStarted signal
+  private void OnSnapStarted(IntPtr data)
+  {
+     SnapStartedEventArgs e = new SnapStartedEventArgs();
+
+     // Populate all members of "e" (SnapStartedEventArgs) with real data
+     e.SnapEventInfo = SnapEvent.GetSnapEventFromPtr( data );
+
+     if (_scrollViewSnapStartedEventHandler != null)
+     {
+        //here we send all data to user event handlers
+        _scrollViewSnapStartedEventHandler(this, e);
+     }
+  }
+
+%}
+
+%enddef
+
+
+%define DALI_SCROLLVIEW_EVENTHANDLER_PARAM( NameSpace, ClassName)
+
+  SCROLLVIEW_EVENTHANDLER_TYPEMAP_EVENTARG( NameSpace, ClassName);
+  SCROLLVIEW_EVENTHANDLER_TYPEMAP_HELPER( NameSpace, ClassName);
+
+%enddef
+
+namespace Dali
+{
+  DALI_SCROLLVIEW_EVENTHANDLER_PARAM( Dali::Toolkit, ScrollView);
+}
diff --git a/plugins/dali-swig/SWIG/events/slider-event.i b/plugins/dali-swig/SWIG/events/slider-event.i
new file mode 100644 (file)
index 0000000..8adf35e
--- /dev/null
@@ -0,0 +1,308 @@
+/*
+ * Copyright (c) 2016 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.
+ *
+ */
+
+%define SLIDER_EVENTHANDLER_TYPEMAP_EVENTARG(NameSpace, ClassName)
+%typemap(csimports) NameSpace::ClassName %{
+using System;
+using System.Runtime.InteropServices;
+
+%}
+%enddef
+
+%define SLIDER_EVENTHANDLER_TYPEMAP_HELPER(NameSpace, ClassName)
+%typemap(cscode) NameSpace::ClassName %{
+
+public class ValueChangedEventArgs : EventArgs
+{
+   private Slider _slider;
+   private float _slideValue;
+
+   public Slider Slider
+   {
+      get
+      {
+         return _slider;
+      }
+      set
+      {
+         _slider = value;
+      }
+   }
+
+   public float SlideValue
+   {
+      get
+      {
+         return _slideValue;
+      }
+      set
+      {
+         _slideValue = value;
+      }
+   }
+}
+
+public class SlidingFinishedEventArgs : EventArgs
+{
+   private Slider _slider;
+   private float _slideValue;
+
+   public Slider Slider
+   {
+      get
+      {
+         return _slider;
+      }
+      set
+      {
+         _slider = value;
+      }
+   }
+
+   public float SlideValue
+   {
+      get
+      {
+         return _slideValue;
+      }
+      set
+      {
+         _slideValue = value;
+      }
+   }
+}
+
+public class MarkReachedEventArgs : EventArgs
+{
+   private Slider _slider;
+   private int _slideValue;
+
+   public Slider Slider
+   {
+      get
+      {
+         return _slider;
+      }
+      set
+      {
+         _slider = value;
+      }
+   }
+
+   public int SlideValue
+   {
+      get
+      {
+         return _slideValue;
+      }
+      set
+      {
+         _slideValue = value;
+      }
+   }
+}
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate bool ValueChangedEventHandler(object source, ValueChangedEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate bool SlidingFinishedEventHandler(object source, SlidingFinishedEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate bool MarkReachedEventHandler(object source, MarkReachedEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate bool ValueChangedCallbackDelegate(IntPtr slider, float slideValue);
+  private ValueChangedEventHandler _sliderValueChangedEventHandler;
+  private ValueChangedCallbackDelegate _sliderValueChangedCallbackDelegate;
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate bool SlidingFinishedCallbackDelegate(IntPtr slider, float slideValue);
+  private SlidingFinishedEventHandler _sliderSlidingFinishedEventHandler;
+  private SlidingFinishedCallbackDelegate _sliderSlidingFinishedCallbackDelegate;
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate bool MarkReachedCallbackDelegate(IntPtr slider, int slideValue);
+  private MarkReachedEventHandler _sliderMarkReachedEventHandler;
+  private MarkReachedCallbackDelegate _sliderMarkReachedCallbackDelegate;
+
+  public event ValueChangedEventHandler ValueChanged
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_sliderValueChangedEventHandler == null)
+           {
+              _sliderValueChangedEventHandler += value;
+
+              _sliderValueChangedCallbackDelegate = new ValueChangedCallbackDelegate(OnValueChanged);
+              this.ValueChangedSignal().Connect(_sliderValueChangedCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_sliderValueChangedEventHandler != null)
+           {
+              this.ValueChangedSignal().Disconnect(_sliderValueChangedCallbackDelegate);
+           }
+
+           _sliderValueChangedEventHandler -= value;
+        }
+     }
+  }
+
+  // Callback for Slider ValueChanged signal
+  private bool OnValueChanged(IntPtr slider, float slideValue)
+  {
+     ValueChangedEventArgs e = new ValueChangedEventArgs();
+
+     // Populate all members of "e" (ValueChangedEventArgs) with real page
+     e.Slider = Slider.GetSliderFromPtr( slider );
+     e.SlideValue = slideValue;
+
+     if (_sliderValueChangedEventHandler != null)
+     {
+        //here we send all page to user event handlers
+      return _sliderValueChangedEventHandler(this, e);
+     }
+     return false;
+  }
+
+  public event SlidingFinishedEventHandler SlidingFinished
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_sliderSlidingFinishedEventHandler == null)
+           {
+              _sliderSlidingFinishedEventHandler += value;
+
+              _sliderSlidingFinishedCallbackDelegate = new SlidingFinishedCallbackDelegate(OnSlidingFinished);
+              this.SlidingFinishedSignal().Connect(_sliderSlidingFinishedCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_sliderSlidingFinishedEventHandler != null)
+           {
+              this.SlidingFinishedSignal().Disconnect(_sliderSlidingFinishedCallbackDelegate);
+           }
+
+           _sliderSlidingFinishedEventHandler -= value;
+        }
+     }
+  }
+
+  // Callback for Slider SlidingFinished signal
+  private bool OnSlidingFinished(IntPtr slider, float slideValue)
+  {
+     SlidingFinishedEventArgs e = new SlidingFinishedEventArgs();
+
+     // Populate all members of "e" (SlidingFinishedEventArgs) with real page
+     e.Slider = Slider.GetSliderFromPtr( slider );
+     e.SlideValue = slideValue;
+
+     if (_sliderSlidingFinishedEventHandler != null)
+     {
+        //here we send all page to user event handlers
+      return _sliderSlidingFinishedEventHandler(this, e);
+     }
+     return false;
+  }
+
+  public event MarkReachedEventHandler MarkReached
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_sliderMarkReachedEventHandler == null)
+           {
+              _sliderMarkReachedEventHandler += value;
+
+              _sliderMarkReachedCallbackDelegate = new MarkReachedCallbackDelegate(OnMarkReached);
+              this.MarkReachedSignal().Connect(_sliderMarkReachedCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_sliderMarkReachedEventHandler != null)
+           {
+              this.MarkReachedSignal().Disconnect(_sliderMarkReachedCallbackDelegate);
+           }
+
+           _sliderMarkReachedEventHandler -= value;
+        }
+     }
+  }
+
+  // Callback for Slider MarkReached signal
+  private bool OnMarkReached(IntPtr slider, int slideValue)
+  {
+     MarkReachedEventArgs e = new MarkReachedEventArgs();
+
+     // Populate all members of "e" (MarkReachedEventArgs) with real page
+     e.Slider = Slider.GetSliderFromPtr( slider );
+     e.SlideValue = slideValue;
+
+     if (_sliderMarkReachedEventHandler != null)
+     {
+        //here we send all page to user event handlers
+      return _sliderMarkReachedEventHandler(this, e);
+     }
+     return false;
+  }
+
+  public static ClassName Get ## ClassName ## FromPtr(global::System.IntPtr cPtr) {
+    ClassName ret = new ClassName(cPtr, false);
+   if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+    return ret;
+  }
+
+%}
+
+%enddef
+
+
+%define DALI_SLIDER_EVENTHANDLER_PARAM( NameSpace, ClassName)
+
+  SLIDER_EVENTHANDLER_TYPEMAP_EVENTARG( NameSpace, ClassName);
+  SLIDER_EVENTHANDLER_TYPEMAP_HELPER( NameSpace, ClassName);
+
+%enddef
+
+namespace Dali
+{
+  DALI_SLIDER_EVENTHANDLER_PARAM( Dali::Toolkit, Slider);
+}
diff --git a/plugins/dali-swig/SWIG/events/stage-event.i b/plugins/dali-swig/SWIG/events/stage-event.i
new file mode 100644 (file)
index 0000000..5cdecaf
--- /dev/null
@@ -0,0 +1,562 @@
+/*
+ * Copyright (c) 2016 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.
+ *
+ */
+
+%define STAGE_EVENTHANDLER_TYPEMAP_EVENTARG(NameSpace, ClassName)
+%typemap(csimports) NameSpace::ClassName %{
+using System;
+using System.Runtime.InteropServices;
+
+%}
+%enddef
+
+%define STAGE_EVENTHANDLER_TYPEMAP_HELPER(NameSpace, ClassName)
+%typemap(cscode) NameSpace::ClassName %{
+
+/**
+  * @brief Event arguments that passed via Touch signal
+  *
+  */
+public class TouchEventArgs : EventArgs
+{
+   private TouchData _touchData;
+
+   /**
+     * @brief TouchData - contains the information of touch points
+     *
+     */
+   public TouchData TouchData
+   {
+      get
+      {
+         return _touchData;
+      }
+      set
+      {
+         _touchData = value;
+      }
+   }
+}
+
+
+/**
+  * @brief Event arguments that passed via Wheel signal
+  *
+  */
+public class WheelEventArgs : EventArgs
+{
+   private WheelEvent _wheelEvent;
+
+   /**
+     * @brief WheelEvent - store a wheel rolling type MOUSE_WHEEL or CUSTOM_WHEEL
+     *
+     */
+   public WheelEvent WheelEvent
+   {
+      get
+      {
+         return _wheelEvent;
+      }
+      set
+      {
+         _wheelEvent = value;
+      }
+   }
+}
+
+/**
+  * @brief Event arguments that passed via KeyEvent signal
+  *
+  */
+public class KeyEventArgs : EventArgs
+{
+   private KeyEvent _keyEvent;
+
+   /**
+     * @brief KeyEvent - is the keyevent sent to Stage.
+     *
+     */
+   public KeyEvent KeyEvent
+   {
+      get
+      {
+         return _keyEvent;
+      }
+      set
+      {
+         _keyEvent = value;
+      }
+   }
+}
+
+/**
+  * @brief Event arguments that passed via EventProcessingFinished signal
+  *
+  */
+public class EventProcessingFinishedEventArgs : EventArgs
+{
+}
+
+/**
+  * @brief Event arguments that passed via ContextLost signal
+  *
+  */
+public class ContextLostEventArgs : EventArgs
+{
+}
+
+/**
+  * @brief Event arguments that passed via ContextRegained signal
+  *
+  */
+public class ContextRegainedEventArgs : EventArgs
+{
+}
+
+/**
+  * @brief Event arguments that passed via SceneCreated signal
+  *
+  */
+public class SceneCreatedEventArgs : EventArgs
+{
+}
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate void TouchEventHandler(object source, TouchEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate void WheelEventHandler(object source, WheelEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate void KeyEventHandler(object source, KeyEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate void EventProcessingFinishedEventHandler(object source, EventProcessingFinishedEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate void ContextLostEventHandler(object source, ContextLostEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate void ContextRegainedEventHandler(object source, ContextRegainedEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate void SceneCreatedEventHandler(object source, SceneCreatedEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate void StageTouchCallbackDelegate(IntPtr data);
+  private TouchEventHandler _stageTouchEventHandler;
+  private StageTouchCallbackDelegate _stageTouchCallbackDelegate;
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate void WheelCallbackDelegate(IntPtr data);
+  private WheelEventHandler _stageWheelEventHandler;
+  private WheelCallbackDelegate _stageWheelCallbackDelegate;
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate void KeyCallbackDelegate(IntPtr data);
+  private KeyEventHandler _stageKeyEventHandler;
+  private KeyCallbackDelegate _stageKeyCallbackDelegate;
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate void EventProcessingFinishedEventCallbackDelegate();
+  private EventProcessingFinishedEventHandler _stageEventProcessingFinishedEventHandler;
+  private EventProcessingFinishedEventCallbackDelegate _stageEventProcessingFinishedEventCallbackDelegate;
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate void ContextLostEventCallbackDelegate();
+  private ContextLostEventHandler _stageContextLostEventHandler;
+  private ContextLostEventCallbackDelegate _stageContextLostEventCallbackDelegate;
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate void ContextRegainedEventCallbackDelegate();
+  private ContextRegainedEventHandler _stageContextRegainedEventHandler;
+  private ContextRegainedEventCallbackDelegate _stageContextRegainedEventCallbackDelegate;
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate void SceneCreatedEventCallbackDelegate();
+  private SceneCreatedEventHandler _stageSceneCreatedEventHandler;
+  private SceneCreatedEventCallbackDelegate _stageSceneCreatedEventCallbackDelegate;
+
+  /**
+    * @brief Event for Touched signal which can be used to subscribe/unsubscribe the event handler
+    * (in the type of TouchEventHandler) provided by the user.
+    * Touched signal is emitted when the screen is touched and when the touch ends
+    * (i.e. the down & up touch events only).
+    *
+    */
+  public event TouchEventHandler Touched
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_stageTouchEventHandler == null)
+           {
+              _stageTouchEventHandler += value;
+
+              _stageTouchCallbackDelegate = new StageTouchCallbackDelegate(OnStageTouch);
+              this.TouchSignal().Connect(_stageTouchCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_stageTouchEventHandler != null)
+           {
+              this.TouchSignal().Disconnect(_stageTouchCallbackDelegate);
+           }
+
+           _stageTouchEventHandler -= value;
+        }
+     }
+  }
+
+  // Callback for Stage Touch signal
+  private void OnStageTouch(IntPtr data)
+  {
+     TouchEventArgs e = new TouchEventArgs();
+
+     // Populate all members of "e" (TouchEventArgs) with real data
+     e.TouchData = TouchData.GetTouchDataFromPtr( data );
+
+     if (_stageTouchEventHandler != null)
+     {
+        //here we send all data to user event handlers
+        _stageTouchEventHandler(this, e);
+     }
+  }
+
+  /**
+    * @brief Event for WheelMoved signal which can be used to subscribe/unsubscribe the event handler
+    * (in the type of WheelEventHandler) provided by the user.
+    * WheelMoved signal is emitted is emitted when wheel event is received.
+    *
+    */
+  public event WheelEventHandler WheelMoved
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_stageWheelEventHandler == null)
+           {
+              _stageWheelEventHandler += value;
+
+              _stageWheelCallbackDelegate = new WheelCallbackDelegate(OnStageWheel);
+              this.WheelEventSignal().Connect(_stageWheelCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_stageWheelEventHandler != null)
+           {
+              this.WheelEventSignal().Disconnect(_stageWheelCallbackDelegate);
+           }
+
+           _stageWheelEventHandler -= value;
+        }
+     }
+  }
+
+  // Callback for Stage WheelEventsignal
+  private void OnStageWheel(IntPtr data)
+  {
+     WheelEventArgs e = new WheelEventArgs();
+
+     // Populate all members of "e" (WheelEventArgs) with real data
+     e.WheelEvent = Dali.WheelEvent.GetWheelEventFromPtr( data );
+
+     if (_stageWheelEventHandler != null)
+     {
+        //here we send all data to user event handlers
+        _stageWheelEventHandler(this, e);
+     }
+  }
+
+  /**
+    * @brief Event for KeyPressed signal which can be used to subscribe/unsubscribe the event handler
+    * (in the type of KeyEventHandler) provided by the user.
+    * KeyPressed signal is emitted is emitted when key event is received.
+    *
+    */
+  public event KeyEventHandler KeyPressed
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_stageKeyEventHandler == null)
+           {
+              _stageKeyEventHandler += value;
+
+              _stageKeyCallbackDelegate = new KeyCallbackDelegate(OnStageKey);
+              this.KeyEventSignal().Connect(_stageKeyCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_stageKeyEventHandler != null)
+           {
+              this.KeyEventSignal().Disconnect(_stageKeyCallbackDelegate);
+           }
+
+           _stageKeyEventHandler -= value;
+        }
+     }
+  }
+
+  // Callback for Stage KeyEventsignal
+  private void OnStageKey(IntPtr keyEvent)
+  {
+     KeyEventArgs e = new KeyEventArgs();
+
+     // Populate all members of "e" (KeyEventArgs) with real data
+     e.KeyEvent = Dali.KeyEvent.GetKeyEventFromPtr( keyEvent );
+
+     if (_stageKeyEventHandler != null)
+     {
+        //here we send all data to user event handlers
+        _stageKeyEventHandler(this, e);
+     }
+  }
+
+  /**
+    * @brief Event for EventProcessingFinished signal which can be used to subscribe/unsubscribe the event handler
+    * (in the type of EventProcessingFinishedEventHandler) provided by the user.
+    * EventProcessingFinished signal is emitted just after the event processing is finished.
+    *
+    */
+  public event EventProcessingFinishedEventHandler EventProcessingFinished
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_stageEventProcessingFinishedEventHandler == null)
+           {
+              _stageEventProcessingFinishedEventHandler += value;
+
+              _stageEventProcessingFinishedEventCallbackDelegate = new EventProcessingFinishedEventCallbackDelegate(OnEventProcessingFinished);
+              this.EventProcessingFinishedSignal().Connect(_stageEventProcessingFinishedEventCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_stageEventProcessingFinishedEventHandler != null)
+           {
+              this.EventProcessingFinishedSignal().Disconnect(_stageEventProcessingFinishedEventCallbackDelegate);
+           }
+
+           _stageEventProcessingFinishedEventHandler -= value;
+        }
+     }
+  }
+
+  // Callback for Stage EventProcessingFinishedSignal
+  private void OnEventProcessingFinished()
+  {
+     EventProcessingFinishedEventArgs e = new EventProcessingFinishedEventArgs();
+
+     if (_stageEventProcessingFinishedEventHandler != null)
+     {
+        //here we send all data to user event handlers
+        _stageEventProcessingFinishedEventHandler(this, e);
+     }
+  }
+
+  /**
+    * @brief Event for ContextLost signal which can be used to subscribe/unsubscribe the event handler
+    * (in the type of ContextLostEventHandler) provided by the user.
+    * ContextLost signal is emitted when the GL context is lost (Platform specific behaviour).
+    *
+    */
+  public event ContextLostEventHandler ContextLost
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_stageContextLostEventHandler == null)
+           {
+              _stageContextLostEventHandler += value;
+
+              _stageContextLostEventCallbackDelegate = new ContextLostEventCallbackDelegate(OnContextLost);
+              this.ContextLostSignal().Connect(_stageContextLostEventCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_stageContextLostEventHandler != null)
+           {
+              this.ContextLostSignal().Disconnect(_stageContextLostEventCallbackDelegate);
+           }
+
+           _stageContextLostEventHandler -= value;
+        }
+     }
+  }
+
+  // Callback for Stage ContextLostSignal
+  private void OnContextLost()
+  {
+     ContextLostEventArgs e = new ContextLostEventArgs();
+
+     if (_stageContextLostEventHandler != null)
+     {
+        //here we send all data to user event handlers
+        _stageContextLostEventHandler(this, e);
+     }
+  }
+
+  /**
+    * @brief Event for ContextRegained signal which can be used to subscribe/unsubscribe the event handler
+    * (in the type of ContextRegainedEventHandler) provided by the user.
+    * ContextRegained signal is emitted when the GL context is regained (Platform specific
+    * behaviour).
+    *
+    */
+  public event ContextRegainedEventHandler ContextRegained
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_stageContextRegainedEventHandler == null)
+           {
+              _stageContextRegainedEventHandler += value;
+
+              _stageContextRegainedEventCallbackDelegate = new ContextRegainedEventCallbackDelegate(OnContextRegained);
+              this.ContextRegainedSignal().Connect(_stageContextRegainedEventCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_stageContextRegainedEventHandler != null)
+           {
+              this.ContextRegainedSignal().Disconnect(_stageContextRegainedEventCallbackDelegate);
+           }
+
+           _stageContextRegainedEventHandler -= value;
+        }
+     }
+  }
+
+  // Callback for Stage ContextRegainedSignal
+  private void OnContextRegained()
+  {
+     ContextRegainedEventArgs e = new ContextRegainedEventArgs();
+
+     if (_stageContextRegainedEventHandler != null)
+     {
+        //here we send all data to user event handlers
+        _stageContextRegainedEventHandler(this, e);
+     }
+  }
+
+  /**
+    * @brief Event for SceneCreated signal which can be used to subscribe/unsubscribe the event handler
+    * (in the type of SceneCreatedEventHandler) provided by the user.
+    * SceneCreated signal is emitted after the initial scene is created.
+    *
+    */
+  public event SceneCreatedEventHandler SceneCreated
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_stageSceneCreatedEventHandler == null)
+           {
+              _stageSceneCreatedEventHandler += value;
+
+              _stageSceneCreatedEventCallbackDelegate = new SceneCreatedEventCallbackDelegate(OnSceneCreated);
+              this.SceneCreatedSignal().Connect(_stageSceneCreatedEventCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_stageSceneCreatedEventHandler != null)
+           {
+              this.SceneCreatedSignal().Disconnect(_stageSceneCreatedEventCallbackDelegate);
+           }
+
+           _stageSceneCreatedEventHandler -= value;
+        }
+     }
+  }
+
+  // Callback for Stage SceneCreatedSignal
+  private void OnSceneCreated()
+  {
+     SceneCreatedEventArgs e = new SceneCreatedEventArgs();
+
+     if (_stageSceneCreatedEventHandler != null)
+     {
+        //here we send all data to user event handlers
+        _stageSceneCreatedEventHandler(this, e);
+     }
+  }
+
+%}
+
+%enddef
+
+
+%define DALI_STAGE_EVENTHANDLER_PARAM( NameSpace, ClassName)
+
+  STAGE_EVENTHANDLER_TYPEMAP_EVENTARG( NameSpace, ClassName);
+  STAGE_EVENTHANDLER_TYPEMAP_HELPER( NameSpace, ClassName);
+
+%enddef
+
+namespace Dali
+{
+  DALI_STAGE_EVENTHANDLER_PARAM( Dali, Stage);
+}
diff --git a/plugins/dali-swig/SWIG/events/stylemanager-event.i b/plugins/dali-swig/SWIG/events/stylemanager-event.i
new file mode 100644 (file)
index 0000000..9aac4bd
--- /dev/null
@@ -0,0 +1,156 @@
+/*
+ * Copyright (c) 2016 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.
+ *
+ */
+
+%define STYLEMANAGER_EVENTHANDLER_TYPEMAP_EVENTARG(NameSpace, ClassName)
+%typemap(csimports) NameSpace::ClassName %{
+using System;
+using System.Runtime.InteropServices;
+%}
+%enddef
+
+%define STYLEMANAGER_EVENTHANDLER_TYPEMAP_HELPER(NameSpace, ClassName)
+%typemap(cscode) NameSpace::ClassName %{
+
+
+/**
+  * @brief Event arguments that passed via StyleChanged signal
+  *
+  */
+public class StyleChangedEventArgs : EventArgs
+{
+   private StyleManager _styleManager;
+   private Dali.StyleChangeType _styleChange;
+
+   /**
+     * @brief StyleManager - is the StyleManager that informs applications of system theme change,
+     * and supports application theme change at runtime.
+     *
+     */
+   public StyleManager StyleManager
+   {
+      get
+      {
+         return _styleManager;
+      }
+      set
+      {
+         _styleManager = value;
+      }
+   }
+
+   /**
+     * @brief StyleChange - contains Style change information (default font changed or
+     * default font size changed or theme has changed)
+     *
+     */
+   public Dali.StyleChangeType StyleChange
+   {
+      get
+      {
+         return _styleChange;
+      }
+      set
+      {
+         _styleChange = value;
+      }
+   }
+
+}
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate void StyleChangedEventHandler(object source, StyleChangedEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate void StyleChangedCallbackDelegate(IntPtr styleManager, Dali.StyleChangeType styleChange);
+  private StyleChangedEventHandler _styleManagerStyleChangedEventHandler;
+  private StyleChangedCallbackDelegate _styleManagerStyleChangedCallbackDelegate;
+
+  /**
+    * @brief Event for StyleChanged signal which can be used to subscribe/unsubscribe the
+    * event handler (in the type of StyleChangedEventHandler) provided by the user.
+    * StyleChanged signal is is emitted after the style (e.g. theme/font change) has changed
+    * and the controls have been informed.
+    */
+  public event StyleChangedEventHandler StyleChanged
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_styleManagerStyleChangedEventHandler == null)
+           {
+              _styleManagerStyleChangedEventHandler += value;
+
+              _styleManagerStyleChangedCallbackDelegate = new StyleChangedCallbackDelegate(OnStyleChanged);
+              this.StyleChangedSignal().Connect(_styleManagerStyleChangedCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_styleManagerStyleChangedEventHandler != null)
+           {
+              this.StyleChangedSignal().Disconnect(_styleManagerStyleChangedCallbackDelegate);
+           }
+
+           _styleManagerStyleChangedEventHandler -= value;
+        }
+     }
+  }
+
+  // Callback for StyleManager StyleChangedsignal
+  private void OnStyleChanged(IntPtr styleManager, Dali.StyleChangeType styleChange)
+  {
+     StyleChangedEventArgs e = new StyleChangedEventArgs();
+
+     // Populate all members of "e" (StyleChangedEventArgs) with real data
+     e.StyleManager = StyleManager.GetStyleManagerFromPtr( styleManager );
+     e.StyleChange = styleChange;
+
+     if (_styleManagerStyleChangedEventHandler != null)
+     {
+        //here we send all data to user event handlers
+        _styleManagerStyleChangedEventHandler(this, e);
+     }
+  }
+
+   public static ClassName Get ## ClassName ## FromPtr(global::System.IntPtr cPtr) {
+      ClassName ret = new ClassName(cPtr, false);
+      if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+      return ret;
+   }
+
+%}
+
+%enddef
+
+
+%define DALI_STYLEMANAGER_EVENTHANDLER_PARAM( NameSpace, ClassName)
+
+  STYLEMANAGER_EVENTHANDLER_TYPEMAP_EVENTARG( NameSpace, ClassName);
+  STYLEMANAGER_EVENTHANDLER_TYPEMAP_HELPER( NameSpace, ClassName);
+
+%enddef
+
+namespace Dali
+{
+  DALI_STYLEMANAGER_EVENTHANDLER_PARAM( Dali::Toolkit, StyleManager);
+}
diff --git a/plugins/dali-swig/SWIG/events/tapgesture-event.i b/plugins/dali-swig/SWIG/events/tapgesture-event.i
new file mode 100644 (file)
index 0000000..3e99e45
--- /dev/null
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) 2016 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.
+ *
+ */
+
+%define TapGesture_EVENTHANDLER_TYPEMAP_EVENTARG(NameSpace, ClassName)
+%typemap(csimports) NameSpace::ClassName %{
+using System;
+using System.Runtime.InteropServices;
+%}
+
+%enddef
+
+%define TapGesture_EVENTHANDLER_TYPEMAP_HELPER(NameSpace, ClassName)
+%typemap(cscode) NameSpace::ClassName %{
+
+
+public class DetectedEventArgs : EventArgs
+{
+   private Actor _actor;
+   private TapGesture _tapGesture;
+
+   public Actor Actor
+   {
+      get
+      {
+         return _actor;
+      }
+      set
+      {
+         _actor = value;
+      }
+   }
+
+   public TapGesture TapGesture
+   {
+      get
+      {
+         return _tapGesture;
+      }
+      set
+      {
+         _tapGesture = value;
+      }
+   }
+}
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate void DetectedEventHandler(object source, DetectedEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate void DetectedCallbackDelegate(IntPtr actor, IntPtr TapGesture);
+  private DetectedEventHandler _tapGestureEventHandler;
+  private DetectedCallbackDelegate _tapGestureCallbackDelegate;
+
+
+  public event DetectedEventHandler Detected
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_tapGestureEventHandler == null)
+           {
+              _tapGestureEventHandler += value;
+
+              _tapGestureCallbackDelegate = new DetectedCallbackDelegate(OnTapGestureDetected);
+              this.DetectedSignal().Connect(_tapGestureCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_tapGestureEventHandler != null)
+           {
+              this.DetectedSignal().Disconnect(_tapGestureCallbackDelegate);
+           }
+
+           _tapGestureEventHandler -= value;
+        }
+     }
+  }
+
+ private void OnTapGestureDetected(IntPtr actor, IntPtr tapGesture)
+  {
+   DetectedEventArgs e = new DetectedEventArgs();
+
+   // Populate all members of "e" (DetectedEventArgs) with real data
+   e.Actor = Actor.GetActorFromPtr(actor);
+   e.TapGesture = Dali.TapGesture.GetTapGestureFromPtr(tapGesture);
+
+   if (_tapGestureEventHandler != null)
+   {
+      //here we send all data to user event handlers
+      _tapGestureEventHandler(this, e);
+   }
+
+  }
+
+
+public static ClassName Get ## ClassName ## FromPtr(global::System.IntPtr cPtr) {
+    ClassName ret = new ClassName(cPtr, false);
+   if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+    return ret;
+  }
+
+%}
+
+%enddef
+
+%define DALI_tapGesture_EVENTHANDLER_PARAM( NameSpace, ClassName)
+
+  TapGesture_EVENTHANDLER_TYPEMAP_EVENTARG( NameSpace, ClassName);
+  TapGesture_EVENTHANDLER_TYPEMAP_HELPER( NameSpace, ClassName);
+
+%enddef
+
+namespace Dali
+{
+  DALI_tapGesture_EVENTHANDLER_PARAM( Dali, TapGestureDetector);
+}
diff --git a/plugins/dali-swig/SWIG/events/texteditor-event.i b/plugins/dali-swig/SWIG/events/texteditor-event.i
new file mode 100644 (file)
index 0000000..72da6ce
--- /dev/null
@@ -0,0 +1,132 @@
+/*
+ * Copyright (c) 2016 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.
+ *
+ */
+
+%define TEXTEDITOR_EVENTHANDLER_TYPEMAP_EVENTARG(NameSpace, ClassName)
+%typemap(csimports) NameSpace::ClassName %{
+using System;
+using System.Runtime.InteropServices;
+
+%}
+
+%enddef
+
+%define TEXTEDITOR_EVENTHANDLER_TYPEMAP_HELPER(NameSpace, ClassName)
+%typemap(cscode) NameSpace::ClassName %{
+
+/**
+  * @brief Event arguments that passed via TextChanged signal
+  *
+  */
+public class TextChangedEventArgs : EventArgs
+{
+   private TextEditor _textEditor;
+   /**
+     * @brief TextEditor - is the texteditor control which has the text contents changed.
+     *
+     */
+   public TextEditor TextEditor
+   {
+      get
+      {
+         return _textEditor;
+      }
+      set
+      {
+         _textEditor = value;
+      }
+   }
+}
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate void TextChangedEventHandler(object source, TextChangedEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate void TextChangedCallbackDelegate(IntPtr textEditor);
+  private TextChangedEventHandler _textEditorTextChangedEventHandler;
+  private TextChangedCallbackDelegate _textEditorTextChangedCallbackDelegate;
+
+  /**
+    * @brief Event for TextChanged signal which can be used to subscribe/unsubscribe the event handler
+    * (in the type of TextChangedEventHandler) provided by the user.
+    * TextChanged signal is emitted when the text changes.
+    */
+  public event TextChangedEventHandler TextChanged
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_textEditorTextChangedEventHandler == null)
+           {
+              _textEditorTextChangedEventHandler += value;
+
+              _textEditorTextChangedCallbackDelegate = new TextChangedCallbackDelegate(OnTextChanged);
+              this.TextChangedSignal().Connect(_textEditorTextChangedCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_textEditorTextChangedEventHandler != null)
+           {
+              this.TextChangedSignal().Disconnect(_textEditorTextChangedCallbackDelegate);
+           }
+
+           _textEditorTextChangedEventHandler -= value;
+        }
+     }
+  }
+
+ private void OnTextChanged(IntPtr textEditor)
+  {
+   TextChangedEventArgs e = new TextChangedEventArgs();
+
+   // Populate all members of "e" (TextChangedEventArgs) with real data
+   e.TextEditor = Dali.TextEditor.GetTextEditorFromPtr(textEditor);
+
+   if (_textEditorTextChangedEventHandler != null)
+   {
+      //here we send all data to user event handlers
+      _textEditorTextChangedEventHandler(this, e);
+   }
+
+  }
+
+ public static ClassName Get ## ClassName ## FromPtr(global::System.IntPtr cPtr) {
+    ClassName ret = new ClassName(cPtr, false);
+   if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+    return ret;
+  }
+
+%}
+
+%enddef
+
+%define DALI_TEXTEDITOR_EVENTHANDLER_PARAM( NameSpace, ClassName)
+
+  TEXTEDITOR_EVENTHANDLER_TYPEMAP_EVENTARG( NameSpace, ClassName);
+  TEXTEDITOR_EVENTHANDLER_TYPEMAP_HELPER( NameSpace, ClassName);
+
+%enddef
+
+namespace Dali
+{
+  DALI_TEXTEDITOR_EVENTHANDLER_PARAM( Dali::Toolkit, TextEditor);
+}
diff --git a/plugins/dali-swig/SWIG/events/textfield-event.i b/plugins/dali-swig/SWIG/events/textfield-event.i
new file mode 100644 (file)
index 0000000..59d89a0
--- /dev/null
@@ -0,0 +1,192 @@
+/*
+ * Copyright (c) 2016 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.
+ *
+ */
+
+%define TEXTFIELD_EVENTHANDLER_TYPEMAP_EVENTARG(NameSpace, ClassName)
+%typemap(csimports) NameSpace::ClassName %{
+using System;
+using System.Runtime.InteropServices;
+
+%}
+
+%enddef
+
+%define TEXTFIELD_EVENTHANDLER_TYPEMAP_HELPER(NameSpace, ClassName)
+%typemap(cscode) NameSpace::ClassName %{
+
+public class TextChangedEventArgs : EventArgs
+{
+   private TextField _textField;
+
+   public TextField TextField
+   {
+      get
+      {
+         return _textField;
+      }
+      set
+      {
+         _textField = value;
+      }
+   }
+}
+
+public class MaxLengthReachedEventArgs : EventArgs
+{
+   private TextField _textField;
+
+   public TextField TextField
+   {
+      get
+      {
+         return _textField;
+      }
+      set
+      {
+         _textField = value;
+      }
+   }
+}
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate void TextChangedEventHandler(object source, TextChangedEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate void MaxLengthReachedEventHandler(object source, MaxLengthReachedEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate void TextChangedCallbackDelegate(IntPtr textField);
+  private TextChangedEventHandler _textFieldTextChangedEventHandler;
+  private TextChangedCallbackDelegate _textFieldTextChangedCallbackDelegate;
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate void MaxLengthReachedCallbackDelegate(IntPtr textField);
+  private MaxLengthReachedEventHandler _textFieldMaxLengthReachedEventHandler;
+  private MaxLengthReachedCallbackDelegate _textFieldMaxLengthReachedCallbackDelegate;
+
+  public event TextChangedEventHandler TextChanged
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_textFieldTextChangedEventHandler == null)
+           {
+              _textFieldTextChangedEventHandler += value;
+
+              _textFieldTextChangedCallbackDelegate = new TextChangedCallbackDelegate(OnTextChanged);
+              this.TextChangedSignal().Connect(_textFieldTextChangedCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_textFieldTextChangedEventHandler != null)
+           {
+              this.TextChangedSignal().Disconnect(_textFieldTextChangedCallbackDelegate);
+           }
+
+           _textFieldTextChangedEventHandler -= value;
+        }
+     }
+  }
+
+ private void OnTextChanged(IntPtr textField)
+  {
+   TextChangedEventArgs e = new TextChangedEventArgs();
+
+   // Populate all members of "e" (TextChangedEventArgs) with real data
+   e.TextField = Dali.TextField.GetTextFieldFromPtr(textField);
+
+   if (_textFieldTextChangedEventHandler != null)
+   {
+      //here we send all data to user event handlers
+      _textFieldTextChangedEventHandler(this, e);
+   }
+
+  }
+
+  public event MaxLengthReachedEventHandler MaxLengthReached
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_textFieldMaxLengthReachedEventHandler == null)
+           {
+              _textFieldMaxLengthReachedEventHandler += value;
+
+              _textFieldMaxLengthReachedCallbackDelegate = new MaxLengthReachedCallbackDelegate(OnMaxLengthReached);
+              this.MaxLengthReachedSignal().Connect(_textFieldMaxLengthReachedCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_textFieldMaxLengthReachedEventHandler != null)
+           {
+              this.MaxLengthReachedSignal().Disconnect(_textFieldMaxLengthReachedCallbackDelegate);
+           }
+
+           _textFieldMaxLengthReachedEventHandler -= value;
+        }
+     }
+  }
+
+ private void OnMaxLengthReached(IntPtr textField)
+  {
+   MaxLengthReachedEventArgs e = new MaxLengthReachedEventArgs();
+
+   // Populate all members of "e" (MaxLengthReachedEventArgs) with real data
+   e.TextField = Dali.TextField.GetTextFieldFromPtr(textField);
+
+   if (_textFieldMaxLengthReachedEventHandler != null)
+   {
+      //here we send all data to user event handlers
+      _textFieldMaxLengthReachedEventHandler(this, e);
+   }
+
+  }
+
+ public static ClassName Get ## ClassName ## FromPtr(global::System.IntPtr cPtr) {
+   ClassName ret = new ClassName(cPtr, false);
+   if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+    return ret;
+  }
+
+%}
+
+%enddef
+
+%define DALI_TEXTFIELD_EVENTHANDLER_PARAM( NameSpace, ClassName)
+
+  TEXTFIELD_EVENTHANDLER_TYPEMAP_EVENTARG( NameSpace, ClassName);
+  TEXTFIELD_EVENTHANDLER_TYPEMAP_HELPER( NameSpace, ClassName);
+
+%enddef
+
+namespace Dali
+{
+  DALI_TEXTFIELD_EVENTHANDLER_PARAM( Dali::Toolkit, TextField);
+}
diff --git a/plugins/dali-swig/SWIG/events/timer-event.i b/plugins/dali-swig/SWIG/events/timer-event.i
new file mode 100644 (file)
index 0000000..a8a5f0e
--- /dev/null
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) 2016 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.
+ *
+ */
+
+%define TIMER_EVENTHANDLER_TYPEMAP_EVENTARG(NameSpace, ClassName)
+%typemap(csimports) NameSpace::ClassName %{
+using System;
+using System.Runtime.InteropServices;
+
+%}
+%enddef
+
+%define TIMER_EVENTHANDLER_TYPEMAP_HELPER(NameSpace, ClassName)
+%typemap(cscode) NameSpace::ClassName %{
+
+  /**
+    * @brief Event arguments that passed via Tick signal
+    *
+    */
+  public class TickEventArgs : EventArgs
+  {
+  }
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate bool TickEventHandler(object source, TickEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate bool TickCallbackDelegate(IntPtr data);
+  private TickEventHandler _timerTickEventHandler;
+  private TickCallbackDelegate _timerTickCallbackDelegate;
+
+  /**
+    * @brief Event for Ticked signal which can be used to subscribe/unsubscribe the event handler
+    * (in the type of TickEventHandler) provided by the user.
+    * Ticked signal is emitted after specified time interval.
+    */
+  public event TickEventHandler Ticked
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_timerTickEventHandler == null)
+           {
+              _timerTickEventHandler += value;
+
+              _timerTickCallbackDelegate = new TickCallbackDelegate(OnTick);
+              this.TickSignal().Connect(_timerTickCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_timerTickEventHandler != null)
+           {
+              this.TickSignal().Disconnect(_timerTickCallbackDelegate);
+           }
+
+           _timerTickEventHandler -= value;
+        }
+     }
+  }
+
+  // Callback for Timer Tick signal
+  private bool OnTick(IntPtr data)
+  {
+     TickEventArgs e = new TickEventArgs();
+
+     if (_timerTickEventHandler != null)
+     {
+        //here we send all data to user event handlers
+        return _timerTickEventHandler(this, e);
+     }
+     return false;
+  }
+
+%}
+
+%enddef
+
+
+%define DALI_TIMER_EVENTHANDLER_PARAM( NameSpace, ClassName)
+
+  TIMER_EVENTHANDLER_TYPEMAP_EVENTARG( NameSpace, ClassName);
+  TIMER_EVENTHANDLER_TYPEMAP_HELPER( NameSpace, ClassName);
+
+%enddef
+
+namespace Dali
+{
+  DALI_TIMER_EVENTHANDLER_PARAM( Dali::Adaptor, Timer);
+}
diff --git a/plugins/dali-swig/SWIG/events/videoview-event.i b/plugins/dali-swig/SWIG/events/videoview-event.i
new file mode 100644 (file)
index 0000000..887e15e
--- /dev/null
@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) 2016 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.
+ *
+ */
+
+%define VIDEOVIEW_EVENTHANDLER_TYPEMAP_EVENTARG(NameSpace, ClassName)
+%typemap(csimports) NameSpace::ClassName %{
+using System;
+using System.Runtime.InteropServices;
+
+%}
+%enddef
+
+%define VIDEOVIEW_EVENTHANDLER_TYPEMAP_HELPER(NameSpace, ClassName)
+%typemap(cscode) NameSpace::ClassName %{
+
+/**
+  * @brief Event arguments that passed via Finished signal
+  *
+  */
+public class FinishedEventArgs : EventArgs
+{
+   private VideoView _videoView;
+
+   /**
+     * @brief VideoView - VideoView is a control for video playback and display.
+     *
+     */
+   public VideoView VideoView
+   {
+      get
+      {
+         return _videoView;
+      }
+      set
+      {
+         _videoView = value;
+      }
+   }
+}
+
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  public delegate void FinishedEventHandler(object source, FinishedEventArgs e);
+
+  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+  private delegate void FinishedCallbackDelegate(IntPtr data);
+  private FinishedEventHandler _videoViewFinishedEventHandler;
+  private FinishedCallbackDelegate _videoViewFinishedCallbackDelegate;
+
+  /**
+    * @brief Event for Finished signal which can be used to subscribe/unsubscribe the event handler
+    * (in the type of FinishedEventHandler) provided by the user.
+    * Finished signal is emitted when a video playback have finished.
+    */
+  public event FinishedEventHandler Finished
+  {
+     add
+     {
+        lock(this)
+        {
+           // Restricted to only one listener
+           if (_videoViewFinishedEventHandler == null)
+           {
+              _videoViewFinishedEventHandler += value;
+
+              _videoViewFinishedCallbackDelegate = new FinishedCallbackDelegate(OnFinished);
+              this.FinishedSignal().Connect(_videoViewFinishedCallbackDelegate);
+           }
+        }
+     }
+
+     remove
+     {
+        lock(this)
+        {
+           if (_videoViewFinishedEventHandler != null)
+           {
+              this.FinishedSignal().Disconnect(_videoViewFinishedCallbackDelegate);
+           }
+
+           _videoViewFinishedEventHandler -= value;
+        }
+     }
+  }
+
+  // Callback for VideoView Finished signal
+  private void OnFinished(IntPtr data)
+  {
+     FinishedEventArgs e = new FinishedEventArgs();
+
+     // Populate all members of "e" (FinishedEventArgs) with real data
+     e.VideoView = VideoView.GetVideoViewFromPtr( data );
+
+     if (_videoViewFinishedEventHandler != null)
+     {
+        //here we send all data to user event handlers
+        _videoViewFinishedEventHandler(this, e);
+     }
+  }
+
+  public static ClassName Get ## ClassName ## FromPtr(global::System.IntPtr cPtr) {
+    ClassName ret = new ClassName(cPtr, false);
+   if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+    return ret;
+  }
+
+%}
+
+%enddef
+
+
+%define DALI_VIDEOVIEW_EVENTHANDLER_PARAM( NameSpace, ClassName)
+
+  VIDEOVIEW_EVENTHANDLER_TYPEMAP_EVENTARG( NameSpace, ClassName);
+  VIDEOVIEW_EVENTHANDLER_TYPEMAP_HELPER( NameSpace, ClassName);
+
+%enddef
+
+namespace Dali
+{
+  DALI_VIDEOVIEW_EVENTHANDLER_PARAM( Dali::Toolkit, VideoView);
+}
index fd57e1c..214abe4 100644 (file)
@@ -81,6 +81,7 @@ DALI_CREATE_C_PTR_TO_CSHARP_FUNCTION( Dali::Toolkit, TextField );
 DALI_CREATE_C_PTR_TO_CSHARP_FUNCTION( Dali::Toolkit, TextField );
 DALI_CREATE_C_PTR_TO_CSHARP_FUNCTION( Dali::Toolkit, VideoView );
 DALI_CREATE_C_PTR_TO_CSHARP_FUNCTION( Dali::Toolkit, Slider );
+DALI_CREATE_C_PTR_TO_CSHARP_FUNCTION( Dali::Toolkit::ScrollView, SnapEvent );
  
   
 
index 65a6ce9..865ce46 100644 (file)
  * so we have make them ourselves
  */
 
+%define SIGNAL_TEMPLATE_HELPER_0( returnType,  returnFunc)
+  template<> class Signal< returnType () >
+  {
+  public:
+    %extend
+    {
+      bool Empty() const
+      {
+         return $self->Empty();
+      }
+      std::size_t GetConnectionCount() const
+      {
+        return $self->GetConnectionCount();
+      }
+      void Connect( returnType ( *func ) () )
+      {
+          $self->Connect( func );
+      }
+      void Disconnect( returnType ( *func ) () )
+      {
+          $self->Disconnect( func );
+      }
+      returnType Emit()
+      {
+          returnFunc $self->Emit();
+      }
+    }
+  };
+%enddef
+
 %define SIGNAL_TEMPLATE_HELPER_1( returnType,  returnFunc, argumentType )
   template<> class Signal< returnType ( argumentType ) >
   {
 %enddef
 
 // Macro to define a csharp signal.
+// 0 param signals ( no return )
+%define DALI_SIGNAL_0_PARAM()
+
+  SIGNAL_TYPEMAP_HELPER( void (*func) () );
+  SIGNAL_TEMPLATE_HELPER_0( void, NO_RETURN_FUNC);
+%enddef
+
 // 1 param signals ( no return )
 %define DALI_SIGNAL_1_PARAM( argumentType1 )
 
 
 namespace Dali
 {
+// Signal< void () >
+DALI_SIGNAL_0_PARAM();
+
 // Signal< void (Actor) >
 DALI_SIGNAL_1_PARAM( Dali::Actor );
 
@@ -279,7 +319,7 @@ DALI_SIGNAL_1_PARAM( const Dali::RefObject* );
 DALI_SIGNAL_1_PARAM( const Dali::RenderTask& );
 
 // Signal< bool ( const Dali::Toolkit::AccessibilityManager& ) >
-DALI_SIGNAL_1_PARAM_RETURN( bool ,const Dali::Toolkit::AccessibilityManager& );
+DALI_SIGNAL_1_PARAM_RETURN( bool ,Dali::Toolkit::AccessibilityManager& );
 
 // Signal< bool ( const Dali::Toolkit::AccessibilityManager&, const Dali::TouchEvent& ) >
 DALI_SIGNAL_2_PARAM_RETURN( bool ,const Dali::Toolkit::AccessibilityManager&, const Dali::TouchEvent& );
@@ -305,6 +345,9 @@ DALI_SIGNAL_3_PARAM_RETURN( Dali::Actor, Dali::Actor, Dali::Actor, Dali::Toolkit
 // void Signal<  Dali::Actor, bool >;
 DALI_SIGNAL_2_PARAM( Dali::Actor, bool);
 
+// void Signal<  Dali::Actor, Dali::Actor >;
+DALI_SIGNAL_2_PARAM( Dali::Actor, Dali::Actor);
+
 // bool Signal< Dali::Toolkit::Button >;
 DALI_SIGNAL_1_PARAM_RETURN( bool, Dali::Toolkit::Button);
 
@@ -327,7 +370,7 @@ DALI_SIGNAL_1_PARAM( const Dali::Vector2& );
 DALI_SIGNAL_1_PARAM( Dali::Toolkit::TextEditor );
 
 // void Signal< Dali::Toolkit::TextField >;
-DALI_SIGNAL_1_PARAM( Dali::Toolkit::TextField )
+DALI_SIGNAL_1_PARAM( Dali::Toolkit::TextField );
 
 // bool Signal< Dali::Toolkit::Control, const Dali::KeyEvent& >;
 DALI_SIGNAL_2_PARAM_RETURN( bool, Dali::Toolkit::Control, const Dali::KeyEvent& );
index 60b6c7a..2e01c02 100644 (file)
@@ -21,164 +21,162 @@ using Dali;
 
 namespace MyCSharpExample
 {
-    class Example
+  class Example
+  {
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    delegate void CallbackDelegate(IntPtr appPtr); // void, void delgate
+
+    private Dali.Application _application;
+
+    public Example(Dali.Application application)
+    {
+      _application = application;
+      Console.WriteLine( "InitSignal connection count = " + _application.InitSignal().GetConnectionCount() );
+
+      _application.Initialized += new Dali.AUIApplicationInitEventHandler(Initialize);
+      Console.WriteLine( "InitSignal connection count = " + _application.InitSignal().GetConnectionCount() );
+    }
+
+    public void Initialize(object source, AUIApplicationInitEventArgs e)
     {
-        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
-        delegate void CallbackDelegate(IntPtr appPtr); // void, void delgate
-
-        private Dali.Application _application;
-
-        public Example(Dali.Application application)
-        {
-            _application = application;
-
-            CallbackDelegate initializeCallback = new CallbackDelegate( Initialize );
-            Console.WriteLine( "InitSignal connection count = " + _application.InitSignal().GetConnectionCount() );
-
-            _application.InitSignal().Connect( initializeCallback );
-            Console.WriteLine( "InitSignal connection count = " + _application.InitSignal().GetConnectionCount() );
-        }
-
-        private void Initialize(IntPtr appPtr)
-        {
-            Handle handle = new Handle();
-            int myPropertyIndex = handle.RegisterProperty("myProperty", new Property.Value(10.0f), Property.AccessMode.READ_WRITE);
-            float myProperty = 0.0f;
-            handle.GetProperty(myPropertyIndex).Get(ref myProperty);
-            Console.WriteLine( "myProperty value: " + myProperty );
-
-            int myPropertyIndex2 = handle.RegisterProperty("myProperty2", new Property.Value(new Vector2(5.0f, 5.0f)), Property.AccessMode.READ_WRITE);
-            Vector2 myProperty2 = new Vector2(0.0f, 0.0f);
-            handle.GetProperty(myPropertyIndex2).Get(myProperty2);
-            Console.WriteLine( "myProperty2 value: " + myProperty2.x + ", " + myProperty2.y );
-
-            Actor actor = new Actor();
-            actor.Size = new Vector3(200.0f, 200.0f, 0.0f);
-            actor.Name = "MyActor";
-            actor.Color = new Vector4(1.0f, 0.0f, 1.0f, 0.8f);
-            Console.WriteLine("Actor id: {0}", actor.GetId());
-            Console.WriteLine("Actor size: " + actor.Size.x + ", " + actor.Size.y);
-            Console.WriteLine("Actor name: " + actor.Name);
-
-            Stage stage = Stage.GetCurrent();
-            stage.SetBackgroundColor( NDalic.WHITE );
-
-            Vector2 stageSize = stage.GetSize();
-            Console.WriteLine("Stage size: " + stageSize.x + ", " + stageSize.y);
-            stage.Add(actor);
-
-            TextLabel text = new TextLabel("Hello Mono World");
-            text.ParentOrigin = NDalic.ParentOriginCenter;
-            text.AnchorPoint = NDalic.AnchorPointCenter;
-            text.HorizontalAlignment = "CENTER";
-            stage.Add(text);
-
-            Console.WriteLine( "Text label text:  " + text.Text );
-
-            Console.WriteLine( "Text label point size:  " + text.PointSize );
-            text.PointSize = 32.0f;
-            Console.WriteLine( "Text label new point size:  " + text.PointSize );
-
-            using (RectInteger ri = new RectInteger(02,05,20,30))
-            {
-                Console.WriteLine( "    Created " + ri );
-                Console.WriteLine( "    IsEmpty() =  " + ri.IsEmpty() );
-                Console.WriteLine( "    Left =  " + ri.Left() );
-                Console.WriteLine( "    Right =  " + ri.Right() );
-                Console.WriteLine( "    Top  = " + ri.Top() );
-                Console.WriteLine( "    Bottom  = " + ri.Bottom() );
-                Console.WriteLine( "    Area  = " + ri.Area() );
-            }
-            Console.WriteLine( " *************************" );
-            using (RectInteger ri2 = new RectInteger(02,05,20,30))
-            {
-                Console.WriteLine( "    Created " + ri2 );
-                ri2.Set(1,1,40,40);
-                Console.WriteLine( "    IsEmpty() =  " + ri2.IsEmpty() );
-                Console.WriteLine( "    Left =  " + ri2.Left() );
-                Console.WriteLine( "    Right =  " + ri2.Right() );
-                Console.WriteLine( "    Top  = " + ri2.Top() );
-                Console.WriteLine( "    Bottom  = " + ri2.Bottom() );
-                Console.WriteLine( "    Area  = " + ri2.Area() );
-            }
-            Console.WriteLine( " *************************" );
-            using (RectDouble rd = new RectDouble(02,05,20.5,30.5))
-            {
-                Console.WriteLine( "    Created " + rd );
-                Console.WriteLine( "    IsEmpty() =  " + rd.IsEmpty() );
-                Console.WriteLine( "    Left =  " + rd.Left() );
-                Console.WriteLine( "    Right =  " + rd.Right() );
-                Console.WriteLine( "    Top  = " + rd.Top() );
-                Console.WriteLine( "    Bottom  = " + rd.Bottom() );
-                Console.WriteLine( "    Area  = " + rd.Area() );
-            }
-            Console.WriteLine( " *************************" );
-            RectDouble rd2 = new RectDouble();
-            rd2.x = 10;
-            rd2.y = 10;
-            rd2.width = 20;
-            rd2.height = 20;
-            Console.WriteLine( "    Created " + rd2 );
-            Console.WriteLine( "    IsEmpty() =  " + rd2.IsEmpty() );
-            Console.WriteLine( "    Left =  " + rd2.Left() );
-            Console.WriteLine( "    Right =  " + rd2.Right() );
-            Console.WriteLine( "    Top  = " + rd2.Top() );
-            Console.WriteLine( "    Bottom  = " + rd2.Bottom() );
-            Console.WriteLine( "    Area  = " + rd2.Area() );
-
-            Console.WriteLine( " *************************" );
-            Vector2 vector2 = new Vector2(100, 50);
-            Console.WriteLine( "    Created " + vector2 );
-            Console.WriteLine( "    Vector2 x =  " + vector2.x + ", y = " + vector2.y );
-            vector2 += new Vector2(20, 20);
-            Console.WriteLine( "    Vector2 x =  " + vector2[0] + ", y = " + vector2[1] );
-            vector2.x += 10;
-            vector2.y += 10;
-            Console.WriteLine( "    Vector2 width =  " + vector2.width + ", height = " + vector2.height );
-            vector2 += new Vector2(15, 15);
-            Console.WriteLine( "    Vector2 width =  " + vector2[0] + ", height = " + vector2[1] );
-
-            Console.WriteLine( " *************************" );
-            Vector3 vector3 = new Vector3(20, 100, 50);
-            Console.WriteLine( "    Created " + vector3 );
-            Console.WriteLine( "    Vector3 x =  " + vector3.x + ", y = " + vector3.y + ", z = " + vector3.z );
-            vector3 += new Vector3(20, 20, 20);
-            Console.WriteLine( "    Vector3 x =  " + vector3[0] + ", y = " + vector3[1] + ", z = " + vector3[2] );
-            vector3.x += 10;
-            vector3.y += 10;
-            vector3.z += 10;
-            Console.WriteLine( "    Vector3 width =  " + vector3.width + ", height = " + vector3.height + ", depth = " + vector3.depth );
-            Vector3 parentOrigin = NDalic.ParentOriginBottomRight;
-            Console.WriteLine( "    parentOrigin x =  " + parentOrigin.x + ", y = " + parentOrigin.y + ", z = " + parentOrigin.z );
-
-            Console.WriteLine( " *************************" );
-            Vector4 vector4 = new Vector4(20, 100, 50, 200);
-            Console.WriteLine( "    Created " + vector4 );
-            Console.WriteLine( "    Vector4 x =  " + vector4.x + ", y = " + vector4.y + ", z = " + vector4.z + ", w = " + vector4.w );
-            vector4 += new Vector4(20, 20, 20, 20);
-            Console.WriteLine( "    Vector4 x =  " + vector4[0] + ", y = " + vector4[1] + ", z = " + vector4[2] + ", w = " + vector4[3] );
-            vector4.x += 10;
-            vector4.y += 10;
-            vector4.z += 10;
-            vector4.w += 10;
-            Console.WriteLine( "    Vector4 r =  " + vector4.r + ", g = " + vector4.g + ", b = " + vector4.b + ", a = " + vector4.a );
-        }
-
-        public void MainLoop()
-        {
-            _application.MainLoop ();
-        }
-
-        /// <summary>
-        /// The main entry point for the application.
-        /// </summary>
-        [STAThread]
-        static void Main(string[] args)
-        {
-            Console.WriteLine ("Hello Mono World");
-
-            Example example = new Example(Application.NewApplication());
-            example.MainLoop ();
-        }
+      Handle handle = new Handle();
+      int myPropertyIndex = handle.RegisterProperty("myProperty", new Property.Value(10.0f), Property.AccessMode.READ_WRITE);
+      float myProperty = 0.0f;
+      handle.GetProperty(myPropertyIndex).Get(ref myProperty);
+      Console.WriteLine( "myProperty value: " + myProperty );
+
+      int myPropertyIndex2 = handle.RegisterProperty("myProperty2", new Property.Value(new Vector2(5.0f, 5.0f)), Property.AccessMode.READ_WRITE);
+      Vector2 myProperty2 = new Vector2(0.0f, 0.0f);
+      handle.GetProperty(myPropertyIndex2).Get(myProperty2);
+      Console.WriteLine( "myProperty2 value: " + myProperty2.x + ", " + myProperty2.y );
+
+      Actor actor = new Actor();
+      actor.Size = new Vector3(200.0f, 200.0f, 0.0f);
+      actor.Name = "MyActor";
+      actor.Color = new Vector4(1.0f, 0.0f, 1.0f, 0.8f);
+      Console.WriteLine("Actor id: {0}", actor.GetId());
+      Console.WriteLine("Actor size: " + actor.Size.x + ", " + actor.Size.y);
+      Console.WriteLine("Actor name: " + actor.Name);
+
+      Stage stage = Stage.GetCurrent();
+      stage.SetBackgroundColor( NDalic.WHITE );
+
+      Vector2 stageSize = stage.GetSize();
+      Console.WriteLine("Stage size: " + stageSize.x + ", " + stageSize.y);
+      stage.Add(actor);
+
+      TextLabel text = new TextLabel("Hello Mono World");
+      text.ParentOrigin = NDalic.ParentOriginCenter;
+      text.AnchorPoint = NDalic.AnchorPointCenter;
+      text.HorizontalAlignment = "CENTER";
+      stage.Add(text);
+
+      Console.WriteLine( "Text label text:  " + text.Text );
+
+      Console.WriteLine( "Text label point size:  " + text.PointSize );
+      text.PointSize = 32.0f;
+      Console.WriteLine( "Text label new point size:  " + text.PointSize );
+
+      using (RectInteger ri = new RectInteger(02,05,20,30))
+      {
+        Console.WriteLine( "    Created " + ri );
+        Console.WriteLine( "    IsEmpty() =  " + ri.IsEmpty() );
+        Console.WriteLine( "    Left =  " + ri.Left() );
+        Console.WriteLine( "    Right =  " + ri.Right() );
+        Console.WriteLine( "    Top  = " + ri.Top() );
+        Console.WriteLine( "    Bottom  = " + ri.Bottom() );
+        Console.WriteLine( "    Area  = " + ri.Area() );
+      }
+      Console.WriteLine( " *************************" );
+      using (RectInteger ri2 = new RectInteger(02,05,20,30))
+      {
+        Console.WriteLine( "    Created " + ri2 );
+        ri2.Set(1,1,40,40);
+        Console.WriteLine( "    IsEmpty() =  " + ri2.IsEmpty() );
+        Console.WriteLine( "    Left =  " + ri2.Left() );
+        Console.WriteLine( "    Right =  " + ri2.Right() );
+        Console.WriteLine( "    Top  = " + ri2.Top() );
+        Console.WriteLine( "    Bottom  = " + ri2.Bottom() );
+        Console.WriteLine( "    Area  = " + ri2.Area() );
+      }
+      Console.WriteLine( " *************************" );
+      using (RectDouble rd = new RectDouble(02,05,20.5,30.5))
+      {
+        Console.WriteLine( "    Created " + rd );
+        Console.WriteLine( "    IsEmpty() =  " + rd.IsEmpty() );
+        Console.WriteLine( "    Left =  " + rd.Left() );
+        Console.WriteLine( "    Right =  " + rd.Right() );
+        Console.WriteLine( "    Top  = " + rd.Top() );
+        Console.WriteLine( "    Bottom  = " + rd.Bottom() );
+        Console.WriteLine( "    Area  = " + rd.Area() );
+      }
+      Console.WriteLine( " *************************" );
+      RectDouble rd2 = new RectDouble();
+      rd2.x = 10;
+      rd2.y = 10;
+      rd2.width = 20;
+      rd2.height = 20;
+      Console.WriteLine( "    Created " + rd2 );
+      Console.WriteLine( "    IsEmpty() =  " + rd2.IsEmpty() );
+      Console.WriteLine( "    Left =  " + rd2.Left() );
+      Console.WriteLine( "    Right =  " + rd2.Right() );
+      Console.WriteLine( "    Top  = " + rd2.Top() );
+      Console.WriteLine( "    Bottom  = " + rd2.Bottom() );
+      Console.WriteLine( "    Area  = " + rd2.Area() );
+
+      Console.WriteLine( " *************************" );
+      Vector2 vector2 = new Vector2(100, 50);
+      Console.WriteLine( "    Created " + vector2 );
+      Console.WriteLine( "    Vector2 x =  " + vector2.x + ", y = " + vector2.y );
+      vector2 += new Vector2(20, 20);
+      Console.WriteLine( "    Vector2 x =  " + vector2[0] + ", y = " + vector2[1] );
+      vector2.x += 10;
+      vector2.y += 10;
+      Console.WriteLine( "    Vector2 width =  " + vector2.width + ", height = " + vector2.height );
+      vector2 += new Vector2(15, 15);
+      Console.WriteLine( "    Vector2 width =  " + vector2[0] + ", height = " + vector2[1] );
+
+      Console.WriteLine( " *************************" );
+      Vector3 vector3 = new Vector3(20, 100, 50);
+      Console.WriteLine( "    Created " + vector3 );
+      Console.WriteLine( "    Vector3 x =  " + vector3.x + ", y = " + vector3.y + ", z = " + vector3.z );
+      vector3 += new Vector3(20, 20, 20);
+      Console.WriteLine( "    Vector3 x =  " + vector3[0] + ", y = " + vector3[1] + ", z = " + vector3[2] );
+      vector3.x += 10;
+      vector3.y += 10;
+      vector3.z += 10;
+      Console.WriteLine( "    Vector3 width =  " + vector3.width + ", height = " + vector3.height + ", depth = " + vector3.depth );
+      Vector3 parentOrigin = NDalic.ParentOriginBottomRight;
+      Console.WriteLine( "    parentOrigin x =  " + parentOrigin.x + ", y = " + parentOrigin.y + ", z = " + parentOrigin.z );
+
+      Console.WriteLine( " *************************" );
+      Vector4 vector4 = new Vector4(20, 100, 50, 200);
+      Console.WriteLine( "    Created " + vector4 );
+      Console.WriteLine( "    Vector4 x =  " + vector4.x + ", y = " + vector4.y + ", z = " + vector4.z + ", w = " + vector4.w );
+      vector4 += new Vector4(20, 20, 20, 20);
+      Console.WriteLine( "    Vector4 x =  " + vector4[0] + ", y = " + vector4[1] + ", z = " + vector4[2] + ", w = " + vector4[3] );
+      vector4.x += 10;
+      vector4.y += 10;
+      vector4.z += 10;
+      vector4.w += 10;
+      Console.WriteLine( "    Vector4 r =  " + vector4.r + ", g = " + vector4.g + ", b = " + vector4.b + ", a = " + vector4.a );
     }
+
+    public void MainLoop()
+    {
+      _application.MainLoop ();
+    }
+
+    /// <summary>
+    /// The main entry point for the application.
+    /// </summary>
+    [STAThread]
+      static void Main(string[] args)
+      {
+        Console.WriteLine ("Hello Mono World");
+
+        Example example = new Example(Application.NewApplication());
+        example.MainLoop ();
+      }
+  }
 }
index d96d977..0a5a841 100755 (executable)
@@ -40,19 +40,16 @@ namespace MyCSharpExample
         public Example(Dali.Application application)
         {
             _application = application;
-
-            CallbackDelegate initializeCallback = new CallbackDelegate( Initialize );
-            _application.InitSignal().Connect( initializeCallback );
+            _application.Initialized += new Dali.AUIApplicationInitEventHandler(Initialize);
         }
 
-        private void Initialize(IntPtr appPtr)
+        public void Initialize(object source, AUIApplicationInitEventArgs e)
         {
+            Console.WriteLine("Customized Application Initialize event handler");
             Stage stage = Stage.GetCurrent();
             stage.SetBackgroundColor( NDalic.WHITE );
 
-            // Connect the signal callback for stage touched signal
-            TouchCallbackDelegate stageTouchedCallback = new TouchCallbackDelegate( OnStageTouched );
-            stage.TouchSignal().Connect( stageTouchedCallback );
+            stage.Touched += new Dali.Stage.TouchEventHandler(OnStageTouched);
 
             // Add a _text label to the stage
             _text = new TextLabel("Hello Mono World");
@@ -65,20 +62,21 @@ namespace MyCSharpExample
         }
 
         // Callback for _animation finished signal handling
-        private void AnimationFinished(IntPtr data)
+        public void AnimationFinished(object source, Animation.FinishedEventArgs e)
         {
-            Animation _animation = Animation.GetAnimationFromPtr( data );
-            Console.WriteLine("Animation finished: duration = " + _animation.GetDuration());
+            Console.WriteLine("Customized Animation Finished Event handler");
+            Console.WriteLine("Animation finished: duration = " + e.Animation.GetDuration());
         }
 
         // Callback for stage touched signal handling
-        private void OnStageTouched(IntPtr data)
+        public void OnStageTouched(object source, Stage.TouchEventArgs e)
         {
-            TouchData touchData = TouchData.GetTouchDataFromPtr( data );
+            //TouchData touchData = TouchData.GetTouchDataFromPtr( data );
 
             // Only animate the _text label when touch down happens
-            if( touchData.GetState(0) == PointStateType.DOWN )
+            if( e.TouchData.GetState(0) == PointStateType.DOWN )
             {
+                Console.WriteLine("Customized Stage Touch event handler");
                 // Create a new _animation
                 if( _animation )
                 {
@@ -91,8 +89,7 @@ namespace MyCSharpExample
                 _animation.AnimateTo(new Property(_text, Actor.Property.ORIENTATION), new Property.Value(new Quaternion( new Radian( new Degree( 0.0f ) ), Vector3.XAXIS )), new AlphaFunction(AlphaFunction.BuiltinFunction.LINEAR), new TimePeriod(0.5f, 0.5f));
 
                 // Connect the signal callback for animaiton finished signal
-                AnimationCallbackDelegate animFinishedDelegate = new AnimationCallbackDelegate( AnimationFinished );
-                _animation.FinishedSignal().Connect( animFinishedDelegate );
+      _animation.Finished += new Dali.Animation.FinishedEventHandler(AnimationFinished);
 
                 // Play the _animation
                 _animation.Play();
index 1c81f38..fa9cc55 100644 (file)
@@ -36,12 +36,11 @@ namespace MyCSharpExample
         public Example(Dali.Application application)
         {
             _application = application;
-
-            CallbackDelegate initializeCallback = new CallbackDelegate( Initialize );
-            _application.InitSignal().Connect( initializeCallback );
+            _application.Initialized += new Dali.AUIApplicationInitEventHandler(Initialize);
         }
 
-        private void Initialize(IntPtr appPtr)
+
+        public void Initialize(object source, AUIApplicationInitEventArgs e)
         {
             CreateScrollView();
         }
@@ -119,11 +118,10 @@ namespace MyCSharpExample
             _scrollView.Add(_scrollBar);
 
             // Connect to the OnRelayout signal
-