[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 DaliEventHandlerWithReturnType<object,StatusChangedEventArgs,bool> _accessibilityManagerStatusChangedEventHandler;
private StatusChangedEventCallbackDelegate _accessibilityManagerStatusChangedEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionNextEventCallbackDelegate(IntPtr accessibilityManager);
- private ActionNextEventHandler _accessibilityManagerActionNextEventHandler;
+ private DaliEventHandlerWithReturnType<object,ActionNextEventArgs,bool> _accessibilityManagerActionNextEventHandler;
private ActionNextEventCallbackDelegate _accessibilityManagerActionNextEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionPreviousEventCallbackDelegate(IntPtr accessibilityManager);
- private ActionPreviousEventHandler _accessibilityManagerActionPreviousEventHandler;
+ private DaliEventHandlerWithReturnType<object,ActionPreviousEventArgs,bool> _accessibilityManagerActionPreviousEventHandler;
private ActionPreviousEventCallbackDelegate _accessibilityManagerActionPreviousEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionActivateEventCallbackDelegate(IntPtr accessibilityManager);
- private ActionActivateEventHandler _accessibilityManagerActionActivateEventHandler;
+ private DaliEventHandlerWithReturnType<object,ActionActivateEventArgs,bool> _accessibilityManagerActionActivateEventHandler;
private ActionActivateEventCallbackDelegate _accessibilityManagerActionActivateEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionReadEventCallbackDelegate(IntPtr accessibilityManager);
- private ActionReadEventHandler _accessibilityManagerActionReadEventHandler;
+ private DaliEventHandlerWithReturnType<object,ActionReadEventArgs,bool> _accessibilityManagerActionReadEventHandler;
private ActionReadEventCallbackDelegate _accessibilityManagerActionReadEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionOverEventCallbackDelegate(IntPtr accessibilityManager);
- private ActionOverEventHandler _accessibilityManagerActionOverEventHandler;
+ private DaliEventHandlerWithReturnType<object,ActionOverEventArgs,bool> _accessibilityManagerActionOverEventHandler;
private ActionOverEventCallbackDelegate _accessibilityManagerActionOverEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionReadNextEventCallbackDelegate(IntPtr accessibilityManager);
- private ActionReadNextEventHandler _accessibilityManagerActionReadNextEventHandler;
+ private DaliEventHandlerWithReturnType<object,ActionReadNextEventArgs,bool> _accessibilityManagerActionReadNextEventHandler;
private ActionReadNextEventCallbackDelegate _accessibilityManagerActionReadNextEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionReadPreviousEventCallbackDelegate(IntPtr accessibilityManager);
- private ActionReadPreviousEventHandler _accessibilityManagerActionReadPreviousEventHandler;
+ private DaliEventHandlerWithReturnType<object,ActionReadPreviousEventArgs,bool> _accessibilityManagerActionReadPreviousEventHandler;
private ActionReadPreviousEventCallbackDelegate _accessibilityManagerActionReadPreviousEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionUpEventCallbackDelegate(IntPtr accessibilityManager);
- private ActionUpEventHandler _accessibilityManagerActionUpEventHandler;
+ private DaliEventHandlerWithReturnType<object,ActionUpEventArgs,bool> _accessibilityManagerActionUpEventHandler;
private ActionUpEventCallbackDelegate _accessibilityManagerActionUpEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionDownEventCallbackDelegate(IntPtr accessibilityManager);
- private ActionDownEventHandler _accessibilityManagerActionDownEventHandler;
+ private DaliEventHandlerWithReturnType<object,ActionDownEventArgs,bool> _accessibilityManagerActionDownEventHandler;
private ActionDownEventCallbackDelegate _accessibilityManagerActionDownEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionClearFocusEventCallbackDelegate(IntPtr accessibilityManager);
- private ActionClearFocusEventHandler _accessibilityManagerActionClearFocusEventHandler;
+ private DaliEventHandlerWithReturnType<object,ActionClearFocusEventArgs,bool> _accessibilityManagerActionClearFocusEventHandler;
private ActionClearFocusEventCallbackDelegate _accessibilityManagerActionClearFocusEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionBackEventCallbackDelegate(IntPtr accessibilityManager);
- private ActionBackEventHandler _accessibilityManagerActionBackEventHandler;
+ private DaliEventHandlerWithReturnType<object,ActionBackEventArgs,bool> _accessibilityManagerActionBackEventHandler;
private ActionBackEventCallbackDelegate _accessibilityManagerActionBackEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionScrollUpEventCallbackDelegate(IntPtr accessibilityManager);
- private ActionScrollUpEventHandler _accessibilityManagerActionScrollUpEventHandler;
+ private DaliEventHandlerWithReturnType<object,ActionScrollUpEventArgs,bool> _accessibilityManagerActionScrollUpEventHandler;
private ActionScrollUpEventCallbackDelegate _accessibilityManagerActionScrollUpEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionScrollDownEventCallbackDelegate(IntPtr accessibilityManager);
- private ActionScrollDownEventHandler _accessibilityManagerActionScrollDownEventHandler;
+ private DaliEventHandlerWithReturnType<object,ActionScrollDownEventArgs,bool> _accessibilityManagerActionScrollDownEventHandler;
private ActionScrollDownEventCallbackDelegate _accessibilityManagerActionScrollDownEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionPageLeftEventCallbackDelegate(IntPtr accessibilityManager);
- private ActionPageLeftEventHandler _accessibilityManagerActionPageLeftEventHandler;
+ private DaliEventHandlerWithReturnType<object,ActionPageLeftEventArgs,bool> _accessibilityManagerActionPageLeftEventHandler;
private ActionPageLeftEventCallbackDelegate _accessibilityManagerActionPageLeftEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionPageRightEventCallbackDelegate(IntPtr accessibilityManager);
- private ActionPageRightEventHandler _accessibilityManagerActionPageRightEventHandler;
+ private DaliEventHandlerWithReturnType<object,ActionPageRightEventArgs,bool> _accessibilityManagerActionPageRightEventHandler;
private ActionPageRightEventCallbackDelegate _accessibilityManagerActionPageRightEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionPageUpEventCallbackDelegate(IntPtr accessibilityManager);
- private ActionPageUpEventHandler _accessibilityManagerActionPageUpEventHandler;
+ private DaliEventHandlerWithReturnType<object,ActionPageUpEventArgs,bool> _accessibilityManagerActionPageUpEventHandler;
private ActionPageUpEventCallbackDelegate _accessibilityManagerActionPageUpEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionPageDownEventCallbackDelegate(IntPtr accessibilityManager);
- private ActionPageDownEventHandler _accessibilityManagerActionPageDownEventHandler;
+ private DaliEventHandlerWithReturnType<object,ActionPageDownEventArgs,bool> _accessibilityManagerActionPageDownEventHandler;
private ActionPageDownEventCallbackDelegate _accessibilityManagerActionPageDownEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionMoveToFirstEventCallbackDelegate(IntPtr accessibilityManager);
- private ActionMoveToFirstEventHandler _accessibilityManagerActionMoveToFirstEventHandler;
+ private DaliEventHandlerWithReturnType<object,ActionMoveToFirstEventArgs,bool> _accessibilityManagerActionMoveToFirstEventHandler;
private ActionMoveToFirstEventCallbackDelegate _accessibilityManagerActionMoveToFirstEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionMoveToLastEventCallbackDelegate(IntPtr accessibilityManager);
- private ActionMoveToLastEventHandler _accessibilityManagerActionMoveToLastEventHandler;
+ private DaliEventHandlerWithReturnType<object,ActionMoveToLastEventArgs,bool> _accessibilityManagerActionMoveToLastEventHandler;
private ActionMoveToLastEventCallbackDelegate _accessibilityManagerActionMoveToLastEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionReadFromTopEventCallbackDelegate(IntPtr accessibilityManager);
- private ActionReadFromTopEventHandler _accessibilityManagerActionReadFromTopEventHandler;
+ private DaliEventHandlerWithReturnType<object,ActionReadFromTopEventArgs,bool> _accessibilityManagerActionReadFromTopEventHandler;
private ActionReadFromTopEventCallbackDelegate _accessibilityManagerActionReadFromTopEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionReadFromNextEventCallbackDelegate(IntPtr accessibilityManager);
- private ActionReadFromNextEventHandler _accessibilityManagerActionReadFromNextEventHandler;
+ private DaliEventHandlerWithReturnType<object,ActionReadFromNextEventArgs,bool> _accessibilityManagerActionReadFromNextEventHandler;
private ActionReadFromNextEventCallbackDelegate _accessibilityManagerActionReadFromNextEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionZoomEventCallbackDelegate(IntPtr accessibilityManager);
- private ActionZoomEventHandler _accessibilityManagerActionZoomEventHandler;
+ private DaliEventHandlerWithReturnType<object,ActionZoomEventArgs,bool> _accessibilityManagerActionZoomEventHandler;
private ActionZoomEventCallbackDelegate _accessibilityManagerActionZoomEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionReadIndicatorInformationEventCallbackDelegate(IntPtr accessibilityManager);
- private ActionReadIndicatorInformationEventHandler _accessibilityManagerActionReadIndicatorInformationEventHandler;
+ private DaliEventHandlerWithReturnType<object,ActionReadIndicatorInformationEventArgs,bool> _accessibilityManagerActionReadIndicatorInformationEventHandler;
private ActionReadIndicatorInformationEventCallbackDelegate _accessibilityManagerActionReadIndicatorInformationEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionReadPauseResumeEventCallbackDelegate(IntPtr accessibilityManager);
- private ActionReadPauseResumeEventHandler _accessibilityManagerActionReadPauseResumeEventHandler;
+ private DaliEventHandlerWithReturnType<object,ActionReadPauseResumeEventArgs,bool> _accessibilityManagerActionReadPauseResumeEventHandler;
private ActionReadPauseResumeEventCallbackDelegate _accessibilityManagerActionReadPauseResumeEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionStartStopEventCallbackDelegate(IntPtr accessibilityManager);
- private ActionStartStopEventHandler _accessibilityManagerActionStartStopEventHandler;
+ private DaliEventHandlerWithReturnType<object,ActionStartStopEventArgs,bool> _accessibilityManagerActionStartStopEventHandler;
private ActionStartStopEventCallbackDelegate _accessibilityManagerActionStartStopEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionScrollEventCallbackDelegate(IntPtr accessibilityManager, IntPtr touchEvent);
- private ActionScrollEventHandler _accessibilityManagerActionScrollEventHandler;
+ private DaliEventHandlerWithReturnType<object,ActionScrollEventArgs,bool> _accessibilityManagerActionScrollEventHandler;
private ActionScrollEventCallbackDelegate _accessibilityManagerActionScrollEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void FocusChangedEventCallbackDelegate(IntPtr actor1, IntPtr actor2);
- private FocusChangedEventHandler _accessibilityManagerFocusChangedEventHandler;
+ private DaliEventHandler<object,FocusChangedEventArgs> _accessibilityManagerFocusChangedEventHandler;
private FocusChangedEventCallbackDelegate _accessibilityManagerFocusChangedEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void FocusedActorActivatedEventCallbackDelegate(IntPtr actor);
- private FocusedActorActivatedEventHandler _accessibilityManagerFocusedActorActivatedEventHandler;
+ private DaliEventHandler<object,FocusedActorActivatedEventArgs> _accessibilityManagerFocusedActorActivatedEventHandler;
private FocusedActorActivatedEventCallbackDelegate _accessibilityManagerFocusedActorActivatedEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void FocusOvershotEventCallbackDelegate(IntPtr currentFocusedActor, AccessibilityManager.FocusOvershotDirection direction);
- private FocusOvershotEventHandler _accessibilityManagerFocusOvershotEventHandler;
+ private DaliEventHandler<object,FocusOvershotEventArgs> _accessibilityManagerFocusOvershotEventHandler;
private FocusOvershotEventCallbackDelegate _accessibilityManagerFocusOvershotEventCallbackDelegate;
- public event StatusChangedEventHandler StatusChanged
+ public event DaliEventHandlerWithReturnType<object,StatusChangedEventArgs,bool> StatusChanged
{
add
{
if (_accessibilityManagerStatusChangedEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerStatusChangedEventHandler(this, e);
+ return _accessibilityManagerStatusChangedEventHandler(this, e, true);
}
return false;
}
- public event ActionNextEventHandler ActionNext
+ public event DaliEventHandlerWithReturnType<object,ActionNextEventArgs,bool> ActionNext
{
add
{
if (_accessibilityManagerActionNextEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionNextEventHandler(this, e);
+ return _accessibilityManagerActionNextEventHandler(this, e, true);
}
return false;
}
- public event ActionPreviousEventHandler ActionPrevious
+ public event DaliEventHandlerWithReturnType<object,ActionPreviousEventArgs,bool> ActionPrevious
{
add
{
if (_accessibilityManagerActionPreviousEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionPreviousEventHandler(this, e);
+ return _accessibilityManagerActionPreviousEventHandler(this, e, true);
}
return false;
}
- public event ActionActivateEventHandler ActionActivate
+ public event DaliEventHandlerWithReturnType<object,ActionActivateEventArgs,bool> ActionActivate
{
add
{
if (_accessibilityManagerActionActivateEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionActivateEventHandler(this, e);
+ return _accessibilityManagerActionActivateEventHandler(this, e, true);
}
return false;
}
- public event ActionReadEventHandler ActionRead
+ public event DaliEventHandlerWithReturnType<object,ActionReadEventArgs,bool> ActionRead
{
add
{
if (_accessibilityManagerActionReadEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionReadEventHandler(this, e);
+ return _accessibilityManagerActionReadEventHandler(this, e, true);
}
return false;
}
- public event ActionOverEventHandler ActionOver
+ public event DaliEventHandlerWithReturnType<object,ActionOverEventArgs,bool> ActionOver
{
add
{
if (_accessibilityManagerActionOverEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionOverEventHandler(this, e);
+ return _accessibilityManagerActionOverEventHandler(this, e, true);
}
return false;
}
- public event ActionReadNextEventHandler ActionReadNext
+ public event DaliEventHandlerWithReturnType<object,ActionReadNextEventArgs,bool> ActionReadNext
{
add
{
if (_accessibilityManagerActionReadNextEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionReadNextEventHandler(this, e);
+ return _accessibilityManagerActionReadNextEventHandler(this, e, true);
}
return false;
}
- public event ActionReadPreviousEventHandler ActionReadPrevious
+ public event DaliEventHandlerWithReturnType<object,ActionReadPreviousEventArgs,bool> ActionReadPrevious
{
add
{
if (_accessibilityManagerActionReadPreviousEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionReadPreviousEventHandler(this, e);
+ return _accessibilityManagerActionReadPreviousEventHandler(this, e, true);
}
return false;
}
- public event ActionUpEventHandler ActionUp
+ public event DaliEventHandlerWithReturnType<object,ActionUpEventArgs,bool> ActionUp
{
add
{
if (_accessibilityManagerActionUpEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionUpEventHandler(this, e);
+ return _accessibilityManagerActionUpEventHandler(this, e, true);
}
return false;
}
- public event ActionDownEventHandler ActionDown
+ public event DaliEventHandlerWithReturnType<object,ActionDownEventArgs,bool> ActionDown
{
add
{
if (_accessibilityManagerActionDownEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionDownEventHandler(this, e);
+ return _accessibilityManagerActionDownEventHandler(this, e, true);
}
return false;
}
- public event ActionClearFocusEventHandler ActionClearFocus
+ public event DaliEventHandlerWithReturnType<object,ActionClearFocusEventArgs,bool> ActionClearFocus
{
add
{
if (_accessibilityManagerActionClearFocusEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionClearFocusEventHandler(this, e);
+ return _accessibilityManagerActionClearFocusEventHandler(this, e, true);
}
return false;
}
- public event ActionBackEventHandler ActionBack
+ public event DaliEventHandlerWithReturnType<object,ActionBackEventArgs,bool> ActionBack
{
add
{
if (_accessibilityManagerActionBackEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionBackEventHandler(this, e);
+ return _accessibilityManagerActionBackEventHandler(this, e, true);
}
return false;
}
- public event ActionScrollUpEventHandler ActionScrollUp
+ public event DaliEventHandlerWithReturnType<object,ActionScrollUpEventArgs,bool> ActionScrollUp
{
add
{
if (_accessibilityManagerActionScrollUpEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionScrollUpEventHandler(this, e);
+ return _accessibilityManagerActionScrollUpEventHandler(this, e, true);
}
return false;
}
- public event ActionScrollDownEventHandler ActionScrollDown
+ public event DaliEventHandlerWithReturnType<object,ActionScrollDownEventArgs,bool> ActionScrollDown
{
add
{
if (_accessibilityManagerActionScrollDownEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionScrollDownEventHandler(this, e);
+ return _accessibilityManagerActionScrollDownEventHandler(this, e, true);
}
return false;
}
- public event ActionPageLeftEventHandler ActionPageLeft
+ public event DaliEventHandlerWithReturnType<object,ActionPageLeftEventArgs,bool> ActionPageLeft
{
add
{
if (_accessibilityManagerActionPageLeftEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionPageLeftEventHandler(this, e);
+ return _accessibilityManagerActionPageLeftEventHandler(this, e, true);
}
return false;
}
- public event ActionPageRightEventHandler ActionPageRight
+ public event DaliEventHandlerWithReturnType<object,ActionPageRightEventArgs,bool> ActionPageRight
{
add
{
if (_accessibilityManagerActionPageRightEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionPageRightEventHandler(this, e);
+ return _accessibilityManagerActionPageRightEventHandler(this, e, true);
}
return false;
}
- public event ActionPageUpEventHandler ActionPageUp
+ public event DaliEventHandlerWithReturnType<object,ActionPageUpEventArgs, bool> ActionPageUp
{
add
{
if (_accessibilityManagerActionPageUpEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionPageUpEventHandler(this, e);
+ return _accessibilityManagerActionPageUpEventHandler(this, e, true);
}
return false;
}
- public event ActionPageDownEventHandler ActionPageDown
+ public event DaliEventHandlerWithReturnType<object,ActionPageDownEventArgs,bool> ActionPageDown
{
add
{
if (_accessibilityManagerActionPageDownEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionPageDownEventHandler(this, e);
+ return _accessibilityManagerActionPageDownEventHandler(this, e, true);
}
return false;
}
- public event ActionMoveToFirstEventHandler ActionMoveToFirst
+ public event DaliEventHandlerWithReturnType<object,ActionMoveToFirstEventArgs,bool> ActionMoveToFirst
{
add
{
if (_accessibilityManagerActionMoveToFirstEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionMoveToFirstEventHandler(this, e);
+ return _accessibilityManagerActionMoveToFirstEventHandler(this, e, true);
}
return false;
}
- public event ActionMoveToLastEventHandler ActionMoveToLast
+ public event DaliEventHandlerWithReturnType<object,ActionMoveToLastEventArgs,bool> ActionMoveToLast
{
add
{
if (_accessibilityManagerActionMoveToLastEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionMoveToLastEventHandler(this, e);
+ return _accessibilityManagerActionMoveToLastEventHandler(this, e, true);
}
return false;
}
- public event ActionReadFromTopEventHandler ActionReadFromTop
+ public event DaliEventHandlerWithReturnType<object,ActionReadFromTopEventArgs,bool> ActionReadFromTop
{
add
{
if (_accessibilityManagerActionReadFromTopEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionReadFromTopEventHandler(this, e);
+ return _accessibilityManagerActionReadFromTopEventHandler(this, e, true);
}
return false;
}
- public event ActionReadFromNextEventHandler ActionReadFromNext
+ public event DaliEventHandlerWithReturnType<object,ActionReadFromNextEventArgs,bool> ActionReadFromNext
{
add
{
if (_accessibilityManagerActionReadFromNextEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionReadFromNextEventHandler(this, e);
+ return _accessibilityManagerActionReadFromNextEventHandler(this, e, true);
}
return false;
}
- public event ActionZoomEventHandler ActionZoom
+ public event DaliEventHandlerWithReturnType<object,ActionZoomEventArgs,bool> ActionZoom
{
add
{
if (_accessibilityManagerActionZoomEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionZoomEventHandler(this, e);
+ return _accessibilityManagerActionZoomEventHandler(this, e, true);
}
return false;
}
- public event ActionReadIndicatorInformationEventHandler ActionReadIndicatorInformation
+ public event DaliEventHandlerWithReturnType<object,ActionReadIndicatorInformationEventArgs,bool> ActionReadIndicatorInformation
{
add
{
if (_accessibilityManagerActionReadIndicatorInformationEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionReadIndicatorInformationEventHandler(this, e);
+ return _accessibilityManagerActionReadIndicatorInformationEventHandler(this, e, true);
}
return false;
}
- public event ActionReadPauseResumeEventHandler ActionReadPauseResume
+ public event DaliEventHandlerWithReturnType<object,ActionReadPauseResumeEventArgs,bool> ActionReadPauseResume
{
add
{
if (_accessibilityManagerActionReadPauseResumeEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionReadPauseResumeEventHandler(this, e);
+ return _accessibilityManagerActionReadPauseResumeEventHandler(this, e, true);
}
return false;
}
- public event ActionStartStopEventHandler ActionStartStop
+ public event DaliEventHandlerWithReturnType<object,ActionStartStopEventArgs,bool> ActionStartStop
{
add
{
if (_accessibilityManagerActionStartStopEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionStartStopEventHandler(this, e);
+ return _accessibilityManagerActionStartStopEventHandler(this, e, true);
}
return false;
}
- public event ActionScrollEventHandler ActionScroll
+ public event DaliEventHandlerWithReturnType<object,ActionScrollEventArgs,bool> ActionScroll
{
add
{
if (_accessibilityManagerActionScrollEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionScrollEventHandler(this, e);
+ return _accessibilityManagerActionScrollEventHandler(this, e, true);
}
return false;
}
- public event FocusChangedEventHandler FocusChanged
+ public event DaliEventHandler<object,FocusChangedEventArgs> FocusChanged
{
add
{
}
}
- public event FocusedActorActivatedEventHandler FocusedActorActivated
+ public event DaliEventHandler<object,FocusedActorActivatedEventArgs> FocusedActorActivated
{
add
{
}
- public event FocusOvershotEventHandler FocusOvershot
+ public event DaliEventHandler<object,FocusOvershotEventArgs> FocusOvershot
{
add
{
[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 DaliEventHandlerWithReturnType<object,TouchEventArgs,bool> _actorTouchDataEventHandler;
private TouchCallbackDelegate _actorTouchDataCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool HoverEventCallbackDelegate(IntPtr actor, IntPtr hoverEvent);
- private HoverEventHandler _actorHoverEventHandler;
+ private DaliEventHandlerWithReturnType<object,HoverEventArgs,bool> _actorHoverEventHandler;
private HoverEventCallbackDelegate _actorHoverEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool WheelEventCallbackDelegate(IntPtr actor, IntPtr wheelEvent);
- private WheelEventHandler _actorWheelEventHandler;
+ private DaliEventHandlerWithReturnType<object,WheelEventArgs,bool> _actorWheelEventHandler;
private WheelEventCallbackDelegate _actorWheelEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void OnStageEventCallbackDelegate(IntPtr actor);
- private OnStageEventHandler _actorOnStageEventHandler;
+ private DaliEventHandler<object,OnStageEventArgs> _actorOnStageEventHandler;
private OnStageEventCallbackDelegate _actorOnStageEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void OffStageEventCallbackDelegate(IntPtr actor);
- private OffStageEventHandler _actorOffStageEventHandler;
+ private DaliEventHandler<object,OffStageEventArgs> _actorOffStageEventHandler;
private OffStageEventCallbackDelegate _actorOffStageEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void OnRelayoutEventCallbackDelegate(IntPtr actor);
- private OnRelayoutEventHandler _actorOnRelayoutEventHandler;
+ private DaliEventHandler<object,OnRelayoutEventArgs> _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.
+ * (in the type of TouchEventHandler-DaliEventHandlerWithReturnType<object,TouchEventArgs,bool>)
+ * provided by the user. Touched signal is emitted when touch input is received.
*/
- public event TouchEventHandler Touched
+ public event DaliEventHandlerWithReturnType<object,TouchEventArgs,bool> Touched
{
add
{
if (_actorTouchDataEventHandler != null)
{
//here we send all data to user event handlers
- return _actorTouchDataEventHandler(this, e);
+ return _actorTouchDataEventHandler(this, e, true);
}
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.
+ * (in the type of HoverEventHandler-DaliEventHandlerWithReturnType<object,HoverEventArgs,bool>)
+ * provided by the user. Hovered signal is emitted when hover input is received.
*/
- public event HoverEventHandler Hovered
+ public event DaliEventHandlerWithReturnType<object,HoverEventArgs,bool> Hovered
{
add
{
if (_actorHoverEventHandler != null)
{
//here we send all data to user event handlers
- return _actorHoverEventHandler(this, e);
+ return _actorHoverEventHandler(this, e, true);
}
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.
+ * (in the type of WheelEventHandler-DaliEventHandlerWithReturnType<object,WheelEventArgs,bool>)
+ * provided by the user. WheelMoved signal is emitted when wheel event is received.
*/
- public event WheelEventHandler WheelMoved
+ public event DaliEventHandlerWithReturnType<object,WheelEventArgs,bool> WheelMoved
{
add
{
if (_actorWheelEventHandler != null)
{
//here we send all data to user event handlers
- return _actorWheelEventHandler(this, e);
+ return _actorWheelEventHandler(this, e, true);
}
return false;
* (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
+ public event DaliEventHandler<object,OnStageEventArgs> OnStageEvent
{
add
{
* (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
+ public event DaliEventHandler<object,OffStageEventArgs> OffStageEvent
{
add
{
* (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
+ public event DaliEventHandler<object,OnRelayoutEventArgs> OnRelayoutEvent
{
add
{
}
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
- public delegate void FinishedEventHandler(object source, FinishedEventArgs e);
-
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void FinishedEventCallbackDelegate(IntPtr Animation);
- private FinishedEventHandler _animationFinishedEventHandler;
+ private DaliEventHandler<object,FinishedEventArgs> _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.
+ * (in the type of FinishedEventHandler - DaliEventHandler<object,FinishedEventArgs>) provided by the user.
* Finished signal is emitted when an Animation's animations have finished.
*/
- public event FinishedEventHandler Finished
+ public event DaliEventHandler<object,FinishedEventArgs> Finished
{
add
{
}
}
}
-
- [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
%typemap(cscode) NameSpace::ClassName %{
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void AUIApplicationInitEventCallbackDelegate(IntPtr application);
- private AUIApplicationInitEventHandler _applicationInitEventHandler;
+ private DaliEventHandler<object,AUIApplicationInitEventArgs> _applicationInitEventHandler;
private AUIApplicationInitEventCallbackDelegate _applicationInitEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void AUIApplicationTerminateEventCallbackDelegate(IntPtr application);
- private AUIApplicationTerminateEventHandler _applicationTerminateEventHandler;
+ private DaliEventHandler<object,AUIApplicationTerminateEventArgs> _applicationTerminateEventHandler;
private AUIApplicationTerminateEventCallbackDelegate _applicationTerminateEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void AUIApplicationPauseEventCallbackDelegate(IntPtr application);
- private AUIApplicationPauseEventHandler _applicationPauseEventHandler;
+ private DaliEventHandler<object,AUIApplicationPauseEventArgs> _applicationPauseEventHandler;
private AUIApplicationPauseEventCallbackDelegate _applicationPauseEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void AUIApplicationResumeEventCallbackDelegate(IntPtr application);
- private AUIApplicationResumeEventHandler _applicationResumeEventHandler;
+ private DaliEventHandler<object,AUIApplicationResumeEventArgs> _applicationResumeEventHandler;
private AUIApplicationResumeEventCallbackDelegate _applicationResumeEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void AUIApplicationResetEventCallbackDelegate(IntPtr application);
- private AUIApplicationResetEventHandler _applicationResetEventHandler;
+ private DaliEventHandler<object,AUIApplicationResetEventArgs> _applicationResetEventHandler;
private AUIApplicationResetEventCallbackDelegate _applicationResetEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void AUIApplicationResizeEventCallbackDelegate(IntPtr application);
- private AUIApplicationResizeEventHandler _applicationResizeEventHandler;
+ private DaliEventHandler<object,AUIApplicationResizeEventArgs> _applicationResizeEventHandler;
private AUIApplicationResizeEventCallbackDelegate _applicationResizeEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void AUIApplicationLanguageChangedEventCallbackDelegate(IntPtr application);
- private AUIApplicationLanguageChangedEventHandler _applicationLanguageChangedEventHandler;
+ private DaliEventHandler<object,AUIApplicationLanguageChangedEventArgs> _applicationLanguageChangedEventHandler;
private AUIApplicationLanguageChangedEventCallbackDelegate _applicationLanguageChangedEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void AUIApplicationRegionChangedEventCallbackDelegate(IntPtr application);
- private AUIApplicationRegionChangedEventHandler _applicationRegionChangedEventHandler;
+ private DaliEventHandler<object,AUIApplicationRegionChangedEventArgs> _applicationRegionChangedEventHandler;
private AUIApplicationRegionChangedEventCallbackDelegate _applicationRegionChangedEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void AUIApplicationBatteryLowEventCallbackDelegate(IntPtr application);
- private AUIApplicationBatteryLowEventHandler _applicationBatteryLowEventHandler;
+ private DaliEventHandler<object,AUIApplicationBatteryLowEventArgs> _applicationBatteryLowEventHandler;
private AUIApplicationBatteryLowEventCallbackDelegate _applicationBatteryLowEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void AUIApplicationMemoryLowEventCallbackDelegate(IntPtr application);
- private AUIApplicationMemoryLowEventHandler _applicationMemoryLowEventHandler;
+ private DaliEventHandler<object,AUIApplicationMemoryLowEventArgs> _applicationMemoryLowEventHandler;
private AUIApplicationMemoryLowEventCallbackDelegate _applicationMemoryLowEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void AUIApplicationAppControlEventCallbackDelegate(IntPtr application, IntPtr voidp);
- private AUIApplicationAppControlEventHandler _applicationAppControlEventHandler;
+ private DaliEventHandler<object,AUIApplicationAppControlEventArgs> _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
+ * (in the type of AUIApplicationInitEventHandler - DaliEventHandler<object,AUIApplicationInitEventArgs>)
+ * provided by the user. Initialized signal is emitted when application is initialised
*/
- public event AUIApplicationInitEventHandler Initialized
+ public event DaliEventHandler<object,AUIApplicationInitEventArgs> Initialized
{
add
{
/**
* @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
+ * (in the type of AUIApplicationTerminateEventHandler-DaliEventHandler<object,AUIApplicationTerminateEventArgs>)
+ * provided by the user. Terminated signal is emitted when application is terminated
*/
- public event AUIApplicationTerminateEventHandler Terminated
+ public event DaliEventHandler<object,AUIApplicationTerminateEventArgs> Terminated
{
add
{
/**
* @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
+ * (in the type of AUIApplicationPauseEventHandler-DaliEventHandler<object,AUIApplicationPauseEventArgs>)
+ * provided by the user. Paused signal is emitted when application is paused
*/
- public event AUIApplicationPauseEventHandler Paused
+ public event DaliEventHandler<object,AUIApplicationPauseEventArgs> Paused
{
add
{
/**
* @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
+ * (in the type of AUIApplicationResumeEventHandler-DaliEventHandler<object,AUIApplicationResumeEventArgs>)
+ * provided by the user. Resumed signal is emitted when application is resumed
*/
- public event AUIApplicationResumeEventHandler Resumed
+ public event DaliEventHandler<object,AUIApplicationResumeEventArgs> Resumed
{
add
{
/**
* @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
+ * (in the type of AUIApplicationResetEventHandler-DaliEventHandler<object,AUIApplicationResetEventArgs>)
+ * provided by the user. Reset signal is emitted when application is reset
*/
- public event AUIApplicationResetEventHandler Reset
+ public event DaliEventHandler<object,AUIApplicationResetEventArgs> Reset
{
add
{
/**
* @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
+ * (in the type of AUIApplicationResizeEventHandler-DaliEventHandler<object,AUIApplicationResizeEventArgs>)
+ * provided by the user. Resized signal is emitted when application is resized
*/
- public event AUIApplicationResizeEventHandler Resized
+ public event DaliEventHandler<object,AUIApplicationResizeEventArgs> Resized
{
add
{
/**
* @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.
+ * (in the type of AUIApplicationLanguageChangedEventHandler-DaliEventHandler<object,AUIApplicationLanguageChangedEventArgs>)
+ * provided by the user. LanguageChanged signal is emitted when the region of the device is changed.
*/
- public event AUIApplicationLanguageChangedEventHandler LanguageChanged
+ public event DaliEventHandler<object,AUIApplicationLanguageChangedEventArgs> LanguageChanged
{
add
{
/**
* @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.
+ * (in the type of AUIApplicationRegionChangedEventHandler-DaliEventHandler<object,AUIApplicationRegionChangedEventArgs>)
+ * provided by the user. RegionChanged signal is emitted when the region of the device is changed.
*/
- public event AUIApplicationRegionChangedEventHandler RegionChanged
+ public event DaliEventHandler<object,AUIApplicationRegionChangedEventArgs> RegionChanged
{
add
{
/**
* @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.
+ * (in the type of AUIApplicationBatteryLowEventHandler-DaliEventHandler<object,AUIApplicationBatteryLowEventArgs>)
+ * provided by the user. BatteryLow signal is emitted when the battery level of the device is low.
*/
- public event AUIApplicationBatteryLowEventHandler BatteryLow
+ public event DaliEventHandler<object,AUIApplicationBatteryLowEventArgs> BatteryLow
{
add
{
/**
* @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.
+ * (in the type of AUIApplicationMemoryLowEventHandler-DaliEventHandler<object,AUIApplicationMemoryLowEventArgs>)
+ * provided by the user. MemoryLow signal is emitted when the memory level of the device is low.
*/
- public event AUIApplicationMemoryLowEventHandler MemoryLow
+ public event DaliEventHandler<object,AUIApplicationMemoryLowEventArgs> MemoryLow
{
add
{
/**
* @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.
+ * (in the type of AUIApplicationAppControlEventHandler-DaliEventHandler<object,AUIApplicationAppControlEventArgs>)
+ * provided by the user. AppControl signal is emitted when another application sends a launch request to the application.
*/
- public event AUIApplicationAppControlEventHandler AppControl
+ public event DaliEventHandler<object,AUIApplicationAppControlEventArgs> AppControl
{
add
{
}
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
- public delegate void QuitEventHandler(object source, QuitEventArgs e);
-
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void QuitEventCallbackDelegate();
- private QuitEventHandler _builderQuitEventHandler;
+ private DaliEventHandler<object,QuitEventArgs> _builderQuitEventHandler;
private QuitEventCallbackDelegate _builderQuitEventCallbackDelegate;
- public event QuitEventHandler Quit
+ public event DaliEventHandler<object,QuitEventArgs> Quit
{
add
{
}
}
- [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 DaliEventHandlerWithReturnType<object,ClickedEventArgs,bool> _buttonClickedEventHandler;
private ClickedCallbackDelegate _buttonClickedCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool PressedCallbackDelegate(global::System.IntPtr data);
- private PressedEventHandler _buttonPressedEventHandler;
+ private DaliEventHandlerWithReturnType<object,PressedEventArgs,bool> _buttonPressedEventHandler;
private PressedCallbackDelegate _buttonPressedCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ReleasedCallbackDelegate(global::System.IntPtr data);
- private ReleasedEventHandler _buttonReleasedEventHandler;
+ private DaliEventHandlerWithReturnType<object,ReleasedEventArgs,bool> _buttonReleasedEventHandler;
private ReleasedCallbackDelegate _buttonReleasedCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool StateChangedCallbackDelegate(global::System.IntPtr data);
- private StateChangedEventHandler _buttonStateChangedEventHandler;
+ private DaliEventHandlerWithReturnType<object,StateChangedEventArgs,bool> _buttonStateChangedEventHandler;
private StateChangedCallbackDelegate _buttonStateChangedCallbackDelegate;
- public event ClickedEventHandler Clicked
+ public event DaliEventHandlerWithReturnType<object,ClickedEventArgs,bool> Clicked
{
add
{
if (_buttonClickedEventHandler != null)
{
//here we send all data to user event handlers
- return _buttonClickedEventHandler(this, e);
+ return _buttonClickedEventHandler(this, e,true);
}
return false;
}
- public event PressedEventHandler Pressed
+ public event DaliEventHandlerWithReturnType<object,PressedEventArgs,bool> Pressed
{
add
{
if (_buttonPressedEventHandler != null)
{
//here we send all data to user event handlers
- return _buttonPressedEventHandler(this, e);
+ return _buttonPressedEventHandler(this, e,true);
}
return false;
}
- public event ReleasedEventHandler Released
+ public event DaliEventHandlerWithReturnType<object,ReleasedEventArgs,bool> Released
{
add
{
if (_buttonReleasedEventHandler != null)
{
//here we send all data to user event handlers
- return _buttonReleasedEventHandler(this, e);
+ return _buttonReleasedEventHandler(this, e, true);
}
return false;
}
- public event StateChangedEventHandler StateChanged
+ public event DaliEventHandlerWithReturnType<object,StateChangedEventArgs,bool> StateChanged
{
add
{
if (_buttonStateChangedEventHandler != null)
{
//here we send all data to user event handlers
- return _buttonStateChangedEventHandler(this, e);
+ return _buttonStateChangedEventHandler(this, e, true);
}
return false;
}
}
[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 view);
- private KeyInputFocusGainedEventHandler _KeyInputFocusGainedEventHandler;
+ private delegate void KeyInputFocusGainedCallbackDelegate(IntPtr control);
+ private DaliEventHandler<object,KeyInputFocusGainedEventArgs> _KeyInputFocusGainedEventHandler;
private KeyInputFocusGainedCallbackDelegate _KeyInputFocusGainedCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
- private delegate void KeyInputFocusLostCallbackDelegate(IntPtr view);
- private KeyInputFocusLostEventHandler _KeyInputFocusLostEventHandler;
+ private delegate void KeyInputFocusLostCallbackDelegate(IntPtr control);
+ private DaliEventHandler<object,KeyInputFocusLostEventArgs> _KeyInputFocusLostEventHandler;
private KeyInputFocusLostCallbackDelegate _KeyInputFocusLostCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
- private delegate bool KeyCallbackDelegate(IntPtr view, IntPtr keyEvent);
- private KeyEventHandler _KeyEventHandler;
+ private delegate bool KeyCallbackDelegate(IntPtr control, IntPtr keyEvent);
+ private DaliEventHandlerWithReturnType<object,KeyEventArgs,bool> _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 view gets Key Input Focus.
+ * (in the type of KeyInputFocusGainedEventHandler-DaliEventHandler<object,KeyInputFocusGainedEventArgs>)
+ * provided by the user. KeyInputFocusGained signal is emitted when the control gets Key Input Focus.
*/
- public event KeyInputFocusGainedEventHandler KeyInputFocusGained
+ public event DaliEventHandler<object,KeyInputFocusGainedEventArgs> KeyInputFocusGained
{
add
{
/**
* @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 view loses Key Input Focus.
+ * (in the type of KeyInputFocusLostEventHandler-DaliEventHandler<object,KeyInputFocusLostEventArgs>)
+ * provided by the user. KeyInputFocusLost signal is emitted when the control loses Key Input Focus.
*/
- public event KeyInputFocusLostEventHandler KeyInputFocusLost
+ public event DaliEventHandler<object,KeyInputFocusLostEventArgs> KeyInputFocusLost
{
add
{
/**
* @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.
+ * (in the type of KeyEventEventHandler-DaliEventHandlerWithReturnType<object,KeyEventArgs,bool>)
+ * provided by the user. KeyPressed signal is emitted when key event is received.
*/
- public event KeyEventHandler KeyPressed
+ public event DaliEventHandlerWithReturnType<object,KeyEventArgs,bool> KeyPressed
{
add
{
if (_KeyEventHandler != null)
{
//here we send all data to user event handlers
- return _KeyEventHandler(this, e);
+ return _KeyEventHandler(this, e, true);
}
return false;
}
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
- public delegate void FinishedEventHandler(object source, FinishedEventArgs e);
-
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void FinishedEventCallbackDelegate(IntPtr application);
- private FinishedEventHandler _gaussianFinishedEventHandler;
+ private DaliEventHandler<object,FinishedEventArgs> _gaussianFinishedEventHandler;
private FinishedEventCallbackDelegate _gaussianFinishedEventCallbackDelegate;
- public event FinishedEventHandler Finished
+ public event DaliEventHandler<object,FinishedEventArgs> Finished
{
add
{
}
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
- public delegate void UploadedEventHandler(object source, UploadedEventArgs e);
-
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void UploadedEventCallbackDelegate(IntPtr image);
- private UploadedEventHandler _imageUploadedEventHandler;
+ private DaliEventHandler<object,UploadedEventArgs> _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.
+ * (in the type of UploadedEventHandler-DaliEventHandler<object,UploadedEventArgs>)
+ * provided by the user. Uploaded signal is emitted when the image data gets uploaded to GL.
*/
- public event UploadedEventHandler Uploaded
+ public event DaliEventHandler<object,UploadedEventArgs> Uploaded
{
add
{
}
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
- public delegate void LayoutActivatedEventHandler(object source, LayoutActivatedEventArgs e);
-
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void LayoutActivatedEventCallbackDelegate();
- private LayoutActivatedEventHandler _itemViewLayoutActivatedEventHandler;
+ private DaliEventHandler<object,LayoutActivatedEventArgs> _itemViewLayoutActivatedEventHandler;
private LayoutActivatedEventCallbackDelegate _itemViewLayoutActivatedEventCallbackDelegate;
- public event LayoutActivatedEventHandler LayoutActivated
+ public event DaliEventHandler<object,LayoutActivatedEventArgs> LayoutActivated
{
add
{
}
[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 DaliEventHandler<object,FocusChangedEventArgs> _keyboardFocusManagerFocusChangedEventHandler;
private FocusChangedEventCallbackDelegate _keyboardFocusManagerFocusChangedEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void FocusGroupChangedEventCallbackDelegate(IntPtr currentFocusedActor, bool forwardDirection);
- private FocusGroupChangedEventHandler _keyboardFocusManagerFocusGroupChangedEventHandler;
+ private DaliEventHandler<object,FocusGroupChangedEventArgs> _keyboardFocusManagerFocusGroupChangedEventHandler;
private FocusGroupChangedEventCallbackDelegate _keyboardFocusManagerFocusGroupChangedEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void FocusedActorEnterKeyEventCallbackDelegate(IntPtr actor);
- private FocusedActorEnterKeyEventHandler _keyboardFocusManagerFocusedActorEnterKeyEventHandler;
+ private DaliEventHandler<object,FocusedActorEnterKeyEventArgs> _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.
+ * (in the type of FocusChangedEventHandler-DaliEventHandler<object,FocusChangedEventArgs>) provided by the user.
* FocusChanged signal is emitted after the current focused actor has been changed.
*/
- public event FocusChangedEventHandler FocusChanged
+ public event DaliEventHandler<object,FocusChangedEventArgs> FocusChanged
{
add
{
/**
* @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.
+ * (in the type of FocusGroupChangedEventHandler-DaliEventHandler<object,FocusGroupChangedEventArgs>)
+ * provided by the user. FocusGroupChanged signal is emitted when the focus group has been changed.
*/
- public event FocusGroupChangedEventHandler FocusGroupChanged
+ public event DaliEventHandler<object,FocusGroupChangedEventArgs> FocusGroupChanged
{
add
{
/**
* @brief Event for FocusedActorEnterKeyPressed signal which can be used to subscribe/unsubscribe the event handler
- * (in the type of FocusedActorEnterKeyEventHandler) provided by the user.
+ * (in the type of FocusedActorEnterKeyEventHandler-DaliEventHandler<object,FocusedActorEnterKeyEventArgs>) provided by the user.
* FocusedActorEnterKeyPressed signal is emitted when the current focused actor has the enter key pressed on it.
*/
- public event FocusedActorEnterKeyEventHandler FocusedActorEnterKeyPressed
+ public event DaliEventHandler<object,FocusedActorEnterKeyEventArgs> FocusedActorEnterKeyPressed
{
add
{
}
[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 DaliEventHandler<object,DetectedEventArgs> _longPressGestureEventHandler;
private DetectedCallbackDelegate _longPressGestureCallbackDelegate;
- public event DetectedEventHandler Detected
+ public event DaliEventHandler<object,DetectedEventArgs> Detected
{
add
{
}
}
- [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 DaliEventHandler<object,ObjectCreatedEventArgs> _objectRegistryObjectCreatedEventHandler;
private ObjectCreatedEventCallbackDelegate _objectRegistryObjectCreatedEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void ObjectDestroyedEventCallbackDelegate(IntPtr fefObject);
- private ObjectDestroyedEventHandler _objectRegistryObjectDestroyedEventHandler;
+ private DaliEventHandler<object,ObjectDestroyedEventArgs> _objectRegistryObjectDestroyedEventHandler;
private ObjectDestroyedEventCallbackDelegate _objectRegistryObjectDestroyedEventCallbackDelegate;
- public event ObjectCreatedEventHandler ObjectCreated
+ public event DaliEventHandler<object,ObjectCreatedEventArgs> ObjectCreated
{
add
{
}
}
- public event ObjectDestroyedEventHandler ObjectDestroyed
+ public event DaliEventHandler<object,ObjectDestroyedEventArgs> ObjectDestroyed
{
add
{
}
[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 DaliEventHandler<object,PagePanStartedEventArgs> _pageTurnViewPagePanStartedEventHandler;
private PagePanStartedCallbackDelegate _pageTurnViewPagePanStartedCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void PagePanFinishedCallbackDelegate(IntPtr page);
- private PagePanFinishedEventHandler _pageTurnViewPagePanFinishedEventHandler;
+ private DaliEventHandler<object,PagePanFinishedEventArgs> _pageTurnViewPagePanFinishedEventHandler;
private PagePanFinishedCallbackDelegate _pageTurnViewPagePanFinishedCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void PageTurnStartedCallbackDelegate(IntPtr page, uint pageIndex, bool isTurningForward);
- private PageTurnStartedEventHandler _pageTurnViewPageTurnStartedEventHandler;
+ private DaliEventHandler<object,PageTurnStartedEventArgs> _pageTurnViewPageTurnStartedEventHandler;
private PageTurnStartedCallbackDelegate _pageTurnViewPageTurnStartedCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void PageTurnFinishedCallbackDelegate(IntPtr page, uint pageIndex, bool isTurningForward);
- private PageTurnFinishedEventHandler _pageTurnViewPageTurnFinishedEventHandler;
+ private DaliEventHandler<object,PageTurnFinishedEventArgs> _pageTurnViewPageTurnFinishedEventHandler;
private PageTurnFinishedCallbackDelegate _pageTurnViewPageTurnFinishedCallbackDelegate;
- public event PagePanStartedEventHandler PagePanStarted
+ public event DaliEventHandler<object,PagePanStartedEventArgs> PagePanStarted
{
add
{
}
}
- public event PagePanFinishedEventHandler PagePanFinished
+ public event DaliEventHandler<object,PagePanFinishedEventArgs> PagePanFinished
{
add
{
}
- public event PageTurnStartedEventHandler PageTurnStarted
+ public event DaliEventHandler<object,PageTurnStartedEventArgs> PageTurnStarted
{
add
{
}
- public event PageTurnFinishedEventHandler PageTurnFinished
+ public event DaliEventHandler<object,PageTurnFinishedEventArgs> PageTurnFinished
{
add
{
}
[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 DaliEventHandler<object,DetectedEventArgs> _panGestureEventHandler;
private DetectedCallbackDelegate _panGestureCallbackDelegate;
- public event DetectedEventHandler Detected
+ public event DaliEventHandler<object,DetectedEventArgs> Detected
{
add
{
}
}
-[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 DaliEventHandler<object,DetectedEventArgs> _pinchGestureEventHandler;
private DetectedCallbackDelegate _pinchGestureCallbackDelegate;
- public event DetectedEventHandler Detected
+ public event DaliEventHandler<object,DetectedEventArgs> Detected
{
add
{
}
[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 DaliEventHandler<object,OutsideTouchedEventArgs> _popUpOutsideTouchedEventHandler;
private OutsideTouchedEventCallbackDelegate _popUpOutsideTouchedEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void ShowingEventCallbackDelegate();
- private ShowingEventHandler _popUpShowingEventHandler;
+ private DaliEventHandler<object,ShowingEventArgs> _popUpShowingEventHandler;
private ShowingEventCallbackDelegate _popUpShowingEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void ShownEventCallbackDelegate();
- private ShownEventHandler _popUpShownEventHandler;
+ private DaliEventHandler<object,ShownEventArgs> _popUpShownEventHandler;
private ShownEventCallbackDelegate _popUpShownEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void HidingEventCallbackDelegate();
- private HidingEventHandler _popUpHidingEventHandler;
+ private DaliEventHandler<object,HidingEventArgs> _popUpHidingEventHandler;
private HidingEventCallbackDelegate _popUpHidingEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void HiddenEventCallbackDelegate();
- private HiddenEventHandler _popUpHiddenEventHandler;
+ private DaliEventHandler<object,HiddenEventArgs> _popUpHiddenEventHandler;
private HiddenEventCallbackDelegate _popUpHiddenEventCallbackDelegate;
- public event OutsideTouchedEventHandler OutsideTouched
+ public event DaliEventHandler<object,OutsideTouchedEventArgs> OutsideTouched
{
add
{
}
}
- public event ShowingEventHandler Showing
+ public event DaliEventHandler<object,ShowingEventArgs> Showing
{
add
{
}
- public event ShownEventHandler Shown
+ public event DaliEventHandler<object,ShownEventArgs> Shown
{
add
{
}
}
- public event HidingEventHandler Hiding
+ public event DaliEventHandler<object,HidingEventArgs> Hiding
{
add
{
}
}
- public event HiddenEventHandler Hidden
+ public event DaliEventHandler<object,HiddenEventArgs> Hidden
{
add
{
}
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
- public delegate void NotifyEventHandler(object source, NotifyEventArgs e);
-
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void NotifyEventCallbackDelegate(IntPtr propertyNotification);
- private NotifyEventHandler _propertyNotificationNotifyEventHandler;
+ private DaliEventHandler<object,NotifyEventArgs> _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.
+ * (in the type of NotifyEventHandler-DaliEventHandler<object,NotifyEventArgs>) 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
+ public event DaliEventHandler<object,NotifyEventArgs> Notified
{
add
{
}
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
- public delegate void RenderTaskEventHandler(object source, FinishedEventArgs e);
-
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void RenderTaskCallbackDelegate(IntPtr renderTask);
- private RenderTaskEventHandler _renderTaskEventHandler;
+ private DaliEventHandler<object,FinishedEventArgs> _renderTaskEventHandler;
private RenderTaskCallbackDelegate _renderTaskCallbackDelegate;
- public event RenderTaskEventHandler Finished
+ public event DaliEventHandler<object,FinishedEventArgs> Finished
{
add
{
}
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
- public delegate void LoadingFinishedEventHandler(object source, LoadingFinishedEventArgs e);
-
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void LoadingFinishedEventCallbackDelegate(IntPtr ResourceImage);
- private LoadingFinishedEventHandler _resourceImageLoadingFinishedEventHandler;
+ private DaliEventHandler<object,LoadingFinishedEventArgs> _resourceImageLoadingFinishedEventHandler;
private LoadingFinishedEventCallbackDelegate _resourceImageLoadingFinishedEventCallbackDelegate;
- public event LoadingFinishedEventHandler LoadingFinished
+ public event DaliEventHandler<object,LoadingFinishedEventArgs> LoadingFinished
{
add
{
}
[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 DaliEventHandler<object,StartedEventArgs> _scrollableStartedEventHandler;
private StartedCallbackDelegate _scrollableStartedCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void UpdatedCallbackDelegate(IntPtr vector2);
- private UpdatedEventHandler _scrollableUpdatedEventHandler;
+ private DaliEventHandler<object,UpdatedEventArgs> _scrollableUpdatedEventHandler;
private UpdatedCallbackDelegate _scrollableUpdatedCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void CompletedCallbackDelegate(IntPtr vector2);
- private CompletedEventHandler _scrollableCompletedEventHandler;
+ private DaliEventHandler<object,CompletedEventArgs> _scrollableCompletedEventHandler;
private CompletedCallbackDelegate _scrollableCompletedCallbackDelegate;
- public event StartedEventHandler ScrollStarted
+ public event DaliEventHandler<object,StartedEventArgs> ScrollStarted
{
add
{
}
- public event UpdatedEventHandler ScrollUpdated
+ public event DaliEventHandler<object,UpdatedEventArgs> ScrollUpdated
{
add
{
}
- public event CompletedEventHandler ScrollCompleted
+ public event DaliEventHandler<object,CompletedEventArgs> ScrollCompleted
{
add
{
}
[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 DaliEventHandler<object,PanFinishedEventArgs> _scrollBarPanFinishedEventHandler;
private PanFinishedEventCallbackDelegate _scrollBarPanFinishedEventCallbackDelegate;
-
+
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void ScrollPositionIntervalReachedEventCallbackDelegate();
- private ScrollPositionIntervalReachedEventHandler _scrollBarScrollPositionIntervalReachedEventHandler;
+ private DaliEventHandler<object,ScrollPositionIntervalReachedEventArgs> _scrollBarScrollPositionIntervalReachedEventHandler;
private ScrollPositionIntervalReachedEventCallbackDelegate _scrollBarScrollPositionIntervalReachedEventCallbackDelegate;
- public event PanFinishedEventHandler PanFinished
+ public event DaliEventHandler<object,PanFinishedEventArgs> PanFinished
{
add
{
}
- public event ScrollPositionIntervalReachedEventHandler ScrollPositionIntervalReached
+ public event DaliEventHandler<object,ScrollPositionIntervalReachedEventArgs> ScrollPositionIntervalReached
{
add
{
}
}
-
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
- public delegate void SnapStartedEventHandler(object source, SnapStartedEventArgs e);
-
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void SnapStartedCallbackDelegate(IntPtr data);
- private SnapStartedEventHandler _scrollViewSnapStartedEventHandler;
+ private DaliEventHandler<object,SnapStartedEventArgs> _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.
+ * (in the type of SnapStartedEventHandler-DaliEventHandler<object,SnapStartedEventArgs>) 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
+ public event DaliEventHandler<object,SnapStartedEventArgs> SnapStarted
{
add
{
}
}
- [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 DaliEventHandlerWithReturnType<object,ValueChangedEventArgs,bool> _sliderValueChangedEventHandler;
private ValueChangedCallbackDelegate _sliderValueChangedCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool SlidingFinishedCallbackDelegate(IntPtr slider, float slideValue);
- private SlidingFinishedEventHandler _sliderSlidingFinishedEventHandler;
+ private DaliEventHandlerWithReturnType<object,SlidingFinishedEventArgs,bool> _sliderSlidingFinishedEventHandler;
private SlidingFinishedCallbackDelegate _sliderSlidingFinishedCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool MarkReachedCallbackDelegate(IntPtr slider, int slideValue);
- private MarkReachedEventHandler _sliderMarkReachedEventHandler;
+ private DaliEventHandlerWithReturnType<object,MarkReachedEventArgs,bool> _sliderMarkReachedEventHandler;
private MarkReachedCallbackDelegate _sliderMarkReachedCallbackDelegate;
- public event ValueChangedEventHandler ValueChanged
+ public event DaliEventHandlerWithReturnType<object,ValueChangedEventArgs,bool> ValueChanged
{
add
{
if (_sliderValueChangedEventHandler != null)
{
//here we send all page to user event handlers
- return _sliderValueChangedEventHandler(this, e);
+ return _sliderValueChangedEventHandler(this, e, true);
}
return false;
}
- public event SlidingFinishedEventHandler SlidingFinished
+ public event DaliEventHandlerWithReturnType<object,SlidingFinishedEventArgs,bool> SlidingFinished
{
add
{
if (_sliderSlidingFinishedEventHandler != null)
{
//here we send all page to user event handlers
- return _sliderSlidingFinishedEventHandler(this, e);
+ return _sliderSlidingFinishedEventHandler(this, e, true);
}
return false;
}
- public event MarkReachedEventHandler MarkReached
+ public event DaliEventHandlerWithReturnType<object,MarkReachedEventArgs,bool> MarkReached
{
add
{
if (_sliderMarkReachedEventHandler != null)
{
//here we send all page to user event handlers
- return _sliderMarkReachedEventHandler(this, e);
+ return _sliderMarkReachedEventHandler(this, e, true);
}
return false;
}
{
}
- [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 DaliEventHandler<object,TouchEventArgs> _stageTouchEventHandler;
private StageTouchCallbackDelegate _stageTouchCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void WheelCallbackDelegate(IntPtr data);
- private WheelEventHandler _stageWheelEventHandler;
+ private DaliEventHandler<object,WheelEventArgs> _stageWheelEventHandler;
private WheelCallbackDelegate _stageWheelCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void KeyCallbackDelegate(IntPtr data);
- private KeyEventHandler _stageKeyEventHandler;
+ private DaliEventHandler<object,KeyEventArgs> _stageKeyEventHandler;
private KeyCallbackDelegate _stageKeyCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void EventProcessingFinishedEventCallbackDelegate();
- private EventProcessingFinishedEventHandler _stageEventProcessingFinishedEventHandler;
+ private DaliEventHandler<object,EventProcessingFinishedEventArgs> _stageEventProcessingFinishedEventHandler;
private EventProcessingFinishedEventCallbackDelegate _stageEventProcessingFinishedEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void ContextLostEventCallbackDelegate();
- private ContextLostEventHandler _stageContextLostEventHandler;
+ private DaliEventHandler<object,ContextLostEventArgs> _stageContextLostEventHandler;
private ContextLostEventCallbackDelegate _stageContextLostEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void ContextRegainedEventCallbackDelegate();
- private ContextRegainedEventHandler _stageContextRegainedEventHandler;
+ private DaliEventHandler<object,ContextRegainedEventArgs> _stageContextRegainedEventHandler;
private ContextRegainedEventCallbackDelegate _stageContextRegainedEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void SceneCreatedEventCallbackDelegate();
- private SceneCreatedEventHandler _stageSceneCreatedEventHandler;
+ private DaliEventHandler<object,SceneCreatedEventArgs> _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.
+ * (in the type of TouchEventHandler-DaliEventHandler<object,TouchEventArgs>) 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
+ public event DaliEventHandler<object,TouchEventArgs> Touched
{
add
{
/**
* @brief Event for WheelMoved signal which can be used to subscribe/unsubscribe the event handler
- * (in the type of WheelEventHandler) provided by the user.
+ * (in the type of WheelEventHandler-DaliEventHandler<object,WheelEventArgs>) provided by the user.
* WheelMoved signal is emitted is emitted when wheel event is received.
*
*/
- public event WheelEventHandler WheelMoved
+ public event DaliEventHandler<object,WheelEventArgs> WheelMoved
{
add
{
/**
* @brief Event for KeyPressed signal which can be used to subscribe/unsubscribe the event handler
- * (in the type of KeyEventHandler) provided by the user.
+ * (in the type of KeyEventHandler-DaliEventHandler<object,KeyEventArgs>) provided by the user.
* KeyPressed signal is emitted is emitted when key event is received.
*
*/
- public event KeyEventHandler KeyPressed
+ public event DaliEventHandler<object,KeyEventArgs> KeyPressed
{
add
{
/**
* @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.
+ * (in the type of EventProcessingFinishedEventHandler-DaliEventHandler<object,EventProcessingFinishedEventArgs>)
+ * provided by the user. EventProcessingFinished signal is emitted just after the event processing is finished.
*
*/
- public event EventProcessingFinishedEventHandler EventProcessingFinished
+ public event DaliEventHandler<object,EventProcessingFinishedEventArgs> EventProcessingFinished
{
add
{
/**
* @brief Event for ContextLost signal which can be used to subscribe/unsubscribe the event handler
- * (in the type of ContextLostEventHandler) provided by the user.
+ * (in the type of ContextLostEventHandler-DaliEventHandler<object,ContextLostEventArgs>) provided by the user.
* ContextLost signal is emitted when the GL context is lost (Platform specific behaviour).
*
*/
- public event ContextLostEventHandler ContextLost
+ public event DaliEventHandler<object,ContextLostEventArgs> ContextLost
{
add
{
/**
* @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
+ * (in the type of ContextRegainedEventHandler-DaliEventHandler<object,ContextRegainedEventArgs>)
+ * provided by the user. ContextRegained signal is emitted when the GL context is regained (Platform specific
* behaviour).
*
*/
- public event ContextRegainedEventHandler ContextRegained
+ public event DaliEventHandler<object,ContextRegainedEventArgs> ContextRegained
{
add
{
/**
* @brief Event for SceneCreated signal which can be used to subscribe/unsubscribe the event handler
- * (in the type of SceneCreatedEventHandler) provided by the user.
+ * (in the type of SceneCreatedEventHandler-DaliEventHandler<object,SceneCreatedEventArgs>) provided by the user.
* SceneCreated signal is emitted after the initial scene is created.
*
*/
- public event SceneCreatedEventHandler SceneCreated
+ public event DaliEventHandler<object,SceneCreatedEventArgs> SceneCreated
{
add
{
}
[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 DaliEventHandler<object,StyleChangedEventArgs> _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
+ * event handler (in the type of StyleChangedEventHandler-DaliEventHandler<object,StyleChangedEventArgs>)
+ * 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
+ public event DaliEventHandler<object,StyleChangedEventArgs> StyleChanged
{
add
{
}
[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 DaliEventHandler<object,DetectedEventArgs> _tapGestureEventHandler;
private DetectedCallbackDelegate _tapGestureCallbackDelegate;
- public event DetectedEventHandler Detected
+ public event DaliEventHandler<object,DetectedEventArgs> Detected
{
add
{
}
}
}
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
- public delegate void TextChangedEventHandler(object source, TextChangedEventArgs e);
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void TextChangedCallbackDelegate(IntPtr textEditor);
- private TextChangedEventHandler _textEditorTextChangedEventHandler;
+ private DaliEventHandler<object,TextChangedEventArgs> _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.
+ * (in the type of TextChangedEventHandler-DaliEventHandler<object,TextChangedEventArgs>)
+ * provided by the user. TextChanged signal is emitted when the text changes.
*/
- public event TextChangedEventHandler TextChanged
+ public event DaliEventHandler<object,TextChangedEventArgs> TextChanged
{
add
{
}
}
- [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 DaliEventHandler<object,TextChangedEventArgs> _textFieldTextChangedEventHandler;
private TextChangedCallbackDelegate _textFieldTextChangedCallbackDelegate;
-
+
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void MaxLengthReachedCallbackDelegate(IntPtr textField);
- private MaxLengthReachedEventHandler _textFieldMaxLengthReachedEventHandler;
+ private DaliEventHandler<object,MaxLengthReachedEventArgs> _textFieldMaxLengthReachedEventHandler;
private MaxLengthReachedCallbackDelegate _textFieldMaxLengthReachedCallbackDelegate;
- public event TextChangedEventHandler TextChanged
+ public event DaliEventHandler<object,TextChangedEventArgs> TextChanged
{
add
{
}
- public event MaxLengthReachedEventHandler MaxLengthReached
+ public event DaliEventHandler<object,MaxLengthReachedEventArgs> MaxLengthReached
{
add
{
}
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
- public delegate bool TickEventHandler(object source, TickEventArgs e);
-
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool TickCallbackDelegate(IntPtr data);
- private TickEventHandler _timerTickEventHandler;
+ private DaliEventHandlerWithReturnType<object,TickEventArgs,bool> _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.
+ * (in the type of TickEventHandler-DaliEventHandlerWithReturnType<object,TickEventArgs,bool>)
+ * provided by the user. Ticked signal is emitted after specified time interval.
*/
- public event TickEventHandler Ticked
+ public event DaliEventHandlerWithReturnType<object,TickEventArgs,bool> Ticked
{
add
{
if (_timerTickEventHandler != null)
{
//here we send all data to user event handlers
- return _timerTickEventHandler(this, e);
+ return _timerTickEventHandler(this, e, true);
}
return false;
}
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
- public delegate void FinishedEventHandler(object source, FinishedEventArgs e);
-
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void FinishedCallbackDelegate(IntPtr data);
- private FinishedEventHandler _videoViewFinishedEventHandler;
+ private DaliEventHandler<object,FinishedEventArgs> _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.
+ * (in the type of FinishedEventHandler-DaliEventHandler<object,FinishedEventArgs>) provided by the user.
* Finished signal is emitted when a video playback have finished.
*/
- public event FinishedEventHandler Finished
+ public event DaliEventHandler<object,FinishedEventArgs> Finished
{
add
{
_application = application;
Console.WriteLine( "InitSignal connection count = " + _application.InitSignal().GetConnectionCount() );
- _application.Initialized += new Dali.AUIApplicationInitEventHandler(Initialize);
+ _application.Initialized += Initialize;
Console.WriteLine( "InitSignal connection count = " + _application.InitSignal().GetConnectionCount() );
}
public Example(Dali.Application application)
{
_application = application;
- _application.Initialized += new Dali.AUIApplicationInitEventHandler(Initialize);
+ _application.Initialized += Initialize;
}
public void Initialize(object source, AUIApplicationInitEventArgs e)
Stage stage = Stage.GetCurrent();
stage.BackgroundColor = NDalic.WHITE;
- stage.Touched += new Dali.Stage.TouchEventHandler(OnStageTouched);
+ stage.Touched += OnStageTouched;
// Add a _text label to the stage
_text = new TextLabel("Hello Mono World");
_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
- _animation.Finished += new Dali.Animation.FinishedEventHandler(AnimationFinished);
+ _animation.Finished += AnimationFinished;
// Play the _animation
_animation.Play();
public Example(Dali.Application application)
{
_application = application;
- _application.Initialized += new Dali.AUIApplicationInitEventHandler(Initialize);
+ _application.Initialized += Initialize;
}
_scrollView.Add(_scrollBar);
// Connect to the OnRelayout signal
- _scrollView.OnRelayoutEvent += new Dali.View.OnRelayoutEventHandler(OnScrollViewRelayout);
+ _scrollView.OnRelayoutEvent += OnScrollViewRelayout;
}
private void OnScrollViewRelayout(object source, View.OnRelayoutEventArgs e)
--- /dev/null
+namespace Dali {
+
+ using System;
+ using System.Runtime.InteropServices;
+
+ [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ public delegate void DaliEventHandler<T,U>(T source, U e);
+
+ [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ public delegate R DaliEventHandlerWithReturnType<T,U,R>(T source, U e, R ret);
+
+}
projects / platform / core / uifw / dali-toolkit.git / commitdiff