};
Size textArea( 100.f, 50.f );
- Size layoutSize( 100.f, 60.f );
+ Size layoutSize( 100.f, 40.f );
LayoutTextData data =
{
};
Size textArea( 100.f, 50.f );
- Size layoutSize( 100.f, 60.f );
+ Size layoutSize( 100.f, 40.f );
LayoutTextData data =
{
END_TEST;
}
+int UtcDaliTextLayoutEllipsis05(void)
+{
+ ToolkitTestApplication application;
+ tet_infoline(" UtcDaliTextLayoutEllipsis05");
+
+ const std::string fontLatin( "TizenSans" );
+
+ // Set a known font description
+ FontDescriptionRun fontDescriptionRun01;
+ fontDescriptionRun01.characterRun.characterIndex = 0u;
+ fontDescriptionRun01.characterRun.numberOfCharacters = 51u;
+ fontDescriptionRun01.familyLength = fontLatin.size();
+ fontDescriptionRun01.familyName = new char[fontDescriptionRun01.familyLength];
+ memcpy( fontDescriptionRun01.familyName, fontLatin.c_str(), fontDescriptionRun01.familyLength );
+ fontDescriptionRun01.familyDefined = true;
+ fontDescriptionRun01.weightDefined = false;
+ fontDescriptionRun01.widthDefined = false;
+ fontDescriptionRun01.slantDefined = false;
+ fontDescriptionRun01.sizeDefined = false;
+
+ Vector<FontDescriptionRun> fontDescriptionRuns;
+ fontDescriptionRuns.PushBack( fontDescriptionRun01 );
+
+ struct LineRun line01 =
+ {
+ { 0u, 11u },
+ { 0u, 11u },
+ 80.f,
+ 15.f,
+ -5.f,
+ 0.f,
+ 0.f,
+ false,
+ true
+ };
+ Vector<LineRun> lines;
+ lines.PushBack( line01 );
+
+ float positions[] =
+ {
+ 1.f, -12.f
+ };
+
+ Size textArea( 100.f, 19.f );
+ Size layoutSize( 100.f, 20.f );
+
+ LayoutTextData data =
+ {
+ "Not enough height.",
+ "Hello world",
+ textArea,
+ 1u,
+ fontDescriptionRuns.Begin(),
+ layoutSize,
+ 1u,
+ positions,
+ 1u,
+ lines.Begin(),
+ LayoutEngine::MULTI_LINE_BOX,
+ 0u,
+ 11u,
+ true,
+ true
+ };
+
+ if( !LayoutTextTest( data ) )
+ {
+ tet_result(TET_FAIL);
+ }
+
+ tet_result(TET_PASS);
+ END_TEST;
+}
+
int UtcDaliTextReorderLayout01(void)
{
ToolkitTestApplication application;
mCore->SurfaceResized( mSurfaceWidth, mSurfaceHeight );
}
+void TestApplication::SetTopMargin( unsigned int margin )
+{
+ mCore->SetTopMargin( margin );
+}
+
void TestApplication::DoUpdate( unsigned int intervalMilliseconds, const char* location )
{
if( GetUpdateStatus() == 0 &&
void ProcessEvent(const Integration::Event& event);
void SendNotification();
void SetSurfaceWidth( unsigned int width, unsigned height );
+ void SetTopMargin( unsigned int margin );
bool Render( unsigned int intervalMilliseconds = DEFAULT_RENDER_INTERVAL, const char* location=NULL );
unsigned int GetUpdateStatus();
bool UpdateOnly( unsigned int intervalMilliseconds = DEFAULT_RENDER_INTERVAL );
*/
// INTERNAL INCLUDES
+
+// EXTERNAL INCLUDES
#include <dali/public-api/images/native-image-interface.h>
#include <dali/devel-api/images/native-image-interface-extension.h>
+#include <dali/integration-api/gl-defines.h>
namespace Dali
{
inline const char* GetCustomFragmentPreFix(){return "#extension GL_OES_EGL_image_external:require\n";}
inline const char* GetCustomSamplerTypename(){return "samplerExternalOES";}
+ inline int GetEglImageTextureTarget(){return GL_TEXTURE_2D;}
+
};
class DALI_IMPORT_API TestNativeImage : public Dali::NativeImageInterface
END_TEST;
}
+
+int UtcDaliToolkitTextlabelEllipsis(void)
+{
+ ToolkitTestApplication application;
+ tet_infoline(" UtcDaliToolkitTextlabelEllipsis");
+
+ TextLabel label = TextLabel::New("Hello world");
+ DALI_TEST_CHECK( label );
+
+ // Avoid a crash when core load gl resources.
+ application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
+
+ Stage::GetCurrent().Add( label );
+
+ // Turn on all the effects
+ label.SetAnchorPoint( AnchorPoint::CENTER );
+ label.SetParentOrigin( ParentOrigin::CENTER );
+ label.SetSize( 360.0f, 10.f );
+
+ try
+ {
+ // Render the text.
+ application.SendNotification();
+ application.Render();
+ }
+ catch( ... )
+ {
+ tet_result(TET_FAIL);
+ }
+
+ END_TEST;
+}
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
// Update the state to indicate the current intent.
mDisplayState = Toolkit::Popup::SHOWING;
+ // We want the popup to have key input focus when it is displayed
+ SetKeyInputFocus();
+
// We are displaying so bring the popup layer to the front, and set it visible so it is rendered.
mLayer.RaiseToTop();
mLayer.SetVisible( true );
if( focusActor )
{
- SetKeyInputFocus();
keyboardFocusManager.SetCurrentFocusActor( focusActor );
}
}
// Don't allow empty handle
if( indicator )
{
+ // Remove current Indicator
+ if( mIndicator )
+ {
+ Self().Remove( mIndicator );
+ }
mIndicator = indicator;
mIndicatorFirstShow = true;
- Self().Add(mIndicator);
+ Self().Add( mIndicator );
- EnableGestureDetection(Gesture::Type(Gesture::Pan));
+ EnableGestureDetection( Gesture::Type( Gesture::Pan ) );
PanGestureDetector detector( GetPanGestureDetector() );
detector.DetachAll();
lineRun->ellipsis = true;
layoutSize.width = layoutParameters.boundingBox.width;
- layoutSize.height += ( lineRun->ascender + -lineRun->descender );
+ if( layoutSize.height < Math::MACHINE_EPSILON_1000 )
+ {
+ layoutSize.height += ( lineRun->ascender + -lineRun->descender );
+ }
SetGlyphPositions( layoutParameters.glyphsBuffer + lineRun->glyphRun.glyphIndex,
ellipsisLayout.numberOfGlyphs,
if( lastLine.ellipsis )
{
+ if( ( 1u == numberOfLines ) &&
+ ( lastLine.ascender - lastLine.descender > mImpl->mVisualModel->mControlSize.height ) )
+ {
+ // Get the first glyph which is going to be replaced and the ellipsis glyph.
+ GlyphInfo& glyphInfo = *glyphs;
+ const GlyphInfo& ellipsisGlyph = mImpl->mFontClient.GetEllipsisGlyph( mImpl->mFontClient.GetPointSize( glyphInfo.fontId ) );
+
+ // Change the 'x' and 'y' position of the ellipsis glyph.
+ Vector2& position = *glyphPositions;
+ position.x = ellipsisGlyph.xBearing;
+ position.y = mImpl->mVisualModel->mControlSize.height - ellipsisGlyph.yBearing;
+
+ // Replace the glyph by the ellipsis glyph.
+ glyphInfo = ellipsisGlyph;
+
+ return 1u;
+ }
+
// firstPenX, penY and firstPenSet are used to position the ellipsis glyph if needed.
float firstPenX = 0.f; // Used if rtl text is elided.
float penY = 0.f;
Vector4 GetBackgroundColor() const;
/**
+ * @DEPRECATED_1_2.8, use Property::BACKGROUND instead
+ *
* @brief Sets an image as the background of the control.
*
* @SINCE_1_0.0
static ImageView New();
/**
+ * @DEPRECATED_1_2.8, use New( const std::string& ) instead.
+ *
* @brief Create an initialized ImageView from an Image instance.
*
* If the handle is empty, ImageView will not display anything.
static ImageView DownCast( BaseHandle handle );
/**
+ * @DEPRECATED_1_2.8, use SetImage( const std::string& ) instead.
+ *
* @brief Sets this ImageView from an Image instance.
*
* If the handle is empty, ImageView will display nothing
const unsigned int TOOLKIT_MAJOR_VERSION = 1;
const unsigned int TOOLKIT_MINOR_VERSION = 2;
-const unsigned int TOOLKIT_MICRO_VERSION = 7;
+const unsigned int TOOLKIT_MICRO_VERSION = 9;
const char * const TOOLKIT_BUILD_DATE = __DATE__ " " __TIME__;
#ifdef DEBUG_ENABLED
-## Network setup
+## Connecting Stagehand to your DALi application
+
+### Preparing DALi
+
+Stagehand connects to DALi via network using a TCP/IP connection, to enable this, your dali-adaptor RPM must be built with a configure option: `--enable-networklogging`
+
+Here is an example dali-adaptor configure line:
+~~~
+$ CXXFLAGS="-g -O0 -Wno-unused-local-typedefs" CXX="ccache g++" ./configure --prefix=$DESKTOP_PREFIX --enable-debug=yes --enable-profile=UBUNTU --enable-gles=20 --enable-networklogging
+~~~
+
+Once this RPM is installed, you can run your DALi application and connect Stagehand to it.
+
+
+### Network setup
To enable network control on DALi, an environment variable must be set:
-## Connecting with Stagehand
+### Connecting with Stagehand
Click the settings icons below
Name: dali-addon
Summary: DALi module for Node.JS
-Version: 1.2.7
+Version: 1.2.9
Release: 1
Group: Development/Libraries
License: Apache License, Version 2.0
Name: dali-toolkit
Summary: The OpenGLES Canvas Core Library Toolkit
-Version: 1.2.7
+Version: 1.2.9
Release: 1
Group: System/Libraries
License: Apache-2.0 and BSD-2-Clause and MIT
# See the License for the specific language governing permissions and
# limitations under the License.
-CLEANFILES = cpp/dali_wrap.* csharp/*.cs *.so *.dll \
+CLEANFILES = automatic/cpp/dali_wrap.* automatic/csharp/*.cs *.so *.dll \
+ manual/cpp/*.o \
examples/*.so examples/*.dll examples/*.exe
-BUILT_SOURCES = cpp/dali_wrap.cpp cpp/dali_wrap.h
+BUILT_SOURCES = automatic/cpp/dali_wrap.cpp automatic/cpp/dali_wrap.h
if HAVE_MCS
if BUILD_MCS
all-local: libNDalic.so NDali.dll
-libNDalic.so: cpp/dali_wrap.o
- g++ -shared cpp/dali_wrap.o -o libNDalic.so $(DALICORE_LIBS) $(DALIADAPTOR_LIBS) $(DALITOOLKIT_LIBS)
+libNDalic.so: automatic/cpp/dali_wrap.o manual/cpp/keyboard_focus_manager_wrap.o
+ g++ -shared automatic/cpp/dali_wrap.o manual/cpp/keyboard_focus_manager_wrap.o -o libNDalic.so $(DALICORE_LIBS) $(DALIADAPTOR_LIBS) $(DALITOOLKIT_LIBS)
-cpp/dali_wrap.o: $(BUILT_SOURCES)
- g++ -c -fpic $(CXXFLAGS) $(DALICORE_CFLAGS) $(DALIADAPTOR_CFLAGS) $(DALITOOLKIT_CFLAGS) cpp/dali_wrap.cpp -o cpp/dali_wrap.o
+automatic/cpp/dali_wrap.o: $(BUILT_SOURCES)
+ g++ -c -fpic $(CXXFLAGS) $(DALICORE_CFLAGS) $(DALIADAPTOR_CFLAGS) $(DALITOOLKIT_CFLAGS) automatic/cpp/dali_wrap.cpp -o automatic/cpp/dali_wrap.o
+
+manual/cpp/keyboard_focus_manager_wrap.o: $(BUILT_SOURCES)
+ g++ -c -fpic $(CXXFLAGS) $(DALICORE_CFLAGS) $(DALIADAPTOR_CFLAGS) $(DALITOOLKIT_CFLAGS) manual/cpp/keyboard_focus_manager_wrap.cpp -o manual/cpp/keyboard_focus_manager_wrap.o
NDali.dll: $(BUILT_SOURCES)
- $(MCS) -nologo -target:library -out:NDali.dll csharp/*.cs
+ $(MCS) -nologo -target:library -out:NDali.dll automatic/csharp/*.cs manual/csharp/*.cs
check-local: examples/dali-test.exe \
examples/hello-world.exe \
# use swig to generate the CS wrapper code
# then call our property-wrapper to inject DALi property getters / setters
$(BUILT_SOURCES): SWIG/*.i
- rm -f csharp/*.cs
- $(SWIG) -csharp -c++ -outdir csharp \
- $(DALI_CFLAGS) $(DALICORE_CFLAGS) $(DALIADAPTOR_CFLAGS) $(DALITOOLKIT_CFLAGS) -namespace Dali -o cpp/dali_wrap.cpp SWIG/dali.i
+ rm -f automatic/csharp/*.cs
+ $(SWIG) -csharp -c++ -outdir automatic/csharp \
+ $(DALI_CFLAGS) $(DALICORE_CFLAGS) $(DALIADAPTOR_CFLAGS) $(DALITOOLKIT_CFLAGS) -namespace Dali -o automatic/cpp/dali_wrap.cpp SWIG/dali.i
./property-wrapper.rb
./constructor-generator.rb
dist-hook: $(BUILT_SOURCES)
- mkdir -p $(distdir)/cpp
- cp ./cpp/dali_wrap.cpp $(distdir)/cpp
- cp ./cpp/dali_wrap.h $(distdir)/cpp
- cp ./cpp/DaliWrapper.h ./cpp/DaliWrapper.cpp $(distdir)/cpp
- cp ./cpp/stdafx.h $(distdir)/cpp
- mkdir -p $(distdir)/csharp
- cp ./csharp/*.csproj $(distdir)/csharp
- cp ./csharp/*.cs $(distdir)/csharp
+ mkdir -p $(distdir)/automatic/cpp
+ cp ./automatic/cpp/*.cpp $(distdir)/automatic/cpp
+ cp ./automatic/cpp/*.h $(distdir)/automatic/cpp
+ mkdir -p $(distdir)/manual/cpp
+ cp ./manual/cpp/*.cpp $(distdir)/manual/cpp
+ cp ./manual/cpp/*.h $(distdir)/manual/cpp
+ mkdir -p $(distdir)/automatic/csharp
+ cp ./automatic/csharp/*.cs $(distdir)/automatic/csharp
+ mkdir -p $(distdir)/manual/csharp
+ cp ./manual/csharp/*.cs $(distdir)/manual/csharp
mkdir -p $(distdir)/examples
cp ./examples/*.csproj $(distdir)/examples
cp ./examples/*.cs $(distdir)/examples
-EXTRA_DIST = \
- swig.cmd
%ignore *::ImageView(Dali::Internal::CustomActor*);
%ignore *::ItemView(Internal::ItemView&);
%ignore *::ItemView(Dali::Internal::CustomActor*);
-%ignore *::KeyboardFocusManager(Internal::KeyboardFocusManager*);
%ignore *::Model3dView(Internal::Model3dView&);
%ignore *::Model3dView(Dali::Internal::CustomActor*);
%ignore *::PageTurnLandscapeView(Internal::PageTurnLandscapeView&);
%ignore *::Button::SetTogglableButton(bool);
%ignore *::Button::SetUnselectedImage(const std::string &);
-%rename(ControlImpl) Dali::Toolkit::Internal::Control;
+%rename(View) Dali::Toolkit::Control;
+%rename(ViewImpl) Dali::Toolkit::Internal::Control;
%rename(VisualBase) Dali::Toolkit::Visual::Base;
%rename(ControlOrientationType) Dali::Toolkit::ControlOrientation::Type;
%rename(DefaultItemLayoutType) Dali::Toolkit::DefaultItemLayout::Type;
%rename(COLOR_VISUAL_MIX_COLOR) Dali::Toolkit::Color::Visual::Property::MIX_COLOR;
%csconstvalue("PropertyRanges.PROPERTY_REGISTRATION_START_INDEX") PROPERTY_START_INDEX;
-%csconstvalue("Control.PropertyRange.PROPERTY_START_INDEX+1000") PROPERTY_END_INDEX;
+%csconstvalue("View.PropertyRange.PROPERTY_START_INDEX+1000") PROPERTY_END_INDEX;
%csconstvalue("PropertyRanges.CHILD_PROPERTY_REGISTRATION_START_INDEX") CHILD_PROPERTY_START_INDEX;
%csconstvalue("PropertyRanges.CHILD_PROPERTY_REGISTRATION_START_INDEX+1000") CHILD_PROPERTY_END_INDEX;
%csconstvalue("PropertyRanges.ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX") ANIMATABLE_PROPERTY_START_INDEX;
%include <dali-toolkit/public-api/controls/text-controls/text-field.h>
%include <dali-toolkit/public-api/controls/text-controls/text-label.h>
%include <dali-toolkit/public-api/accessibility-manager/accessibility-manager.h>
-%include <dali-toolkit/public-api/focus-manager/keyboard-focus-manager.h>
%include <dali-toolkit/public-api/styling/style-manager.h>
%include <dali-toolkit/public-api/controls/slider/slider.h>
%include <dali-toolkit/public-api/controls/video-view/video-view.h>
%template(AccessibilityActionScrollSignal) Dali::Signal<bool(Dali::Toolkit::AccessibilityManager&, const Dali::TouchEvent&)>;
%template(AccessibilityFocusOvershotSignal) Dali::Signal<void(Dali::Actor, Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)>;
%template(FocusChangedSignal) Dali::Signal<void(Dali::Actor, Dali::Actor)>;
-%template(KeyboardPreFocusChangeSignal) Dali::Signal<Dali::Actor(Dali::Actor, Dali::Actor, Dali::Toolkit::Control::KeyboardFocus::Direction)>;
%template(FocusGroupChangedSignal) Dali::Signal<void(Dali::Actor, bool)>;
%template(StyleChangedSignal) Dali::Signal<void(Dali::Toolkit::StyleManager, Dali::StyleChange::Type)>;
%template(ButtonSignal) Dali::Signal<bool(Dali::Toolkit::Button)>;
#include <dali/public-api/math/viewport.h>
#include <dali/public-api/object/property-key.h>
-
#include <dali/public-api/adaptor-framework/timer.h>
#include <dali/public-api/adaptor-framework/window.h>
#include <dali/public-api/adaptor-framework/style-change.h>
{
return (IntPtr)swigCPtr;
}
- %}
- %enddef
+ public Actor Parent
+ {
+ get
+ {
+ Actor parent = GetParent();
+ return parent;
+ }
+ }
+
+ public bool Vibility
+ {
+ get
+ {
+ bool visibility = IsVisible();
+ return visibility;
+ }
+ }
+
+ public float Opacity
+ {
+ set
+ {
+ SetOpacity(value);
+ }
+ }
+
+ public float CurrentOpacity
+ {
+ get
+ {
+ float ret = GetCurrentOpacity();
+ return ret;
+ }
+ }
+
+ public bool StateFocusEnable
+ {
+ set
+ {
+ SetKeyboardFocusable(value);
+ }
+ get
+ {
+ bool focusable = IsKeyboardFocusable();
+ return focusable;
+ }
+ }
+
+%}
+
+%enddef
%define DALI_ACTOR_EVENTHANDLER_PARAM( NameSpace, ClassName)
- ACTOR_EVENTHANDLER_TYPEMAP_EVENTARG( NameSpace, ClassName);
- ACTOR_EVENTHANDLER_TYPEMAP_HELPER( NameSpace, ClassName);
+ACTOR_EVENTHANDLER_TYPEMAP_EVENTARG( NameSpace, ClassName);
+ACTOR_EVENTHANDLER_TYPEMAP_HELPER( NameSpace, ClassName);
- %enddef
+%enddef
- namespace Dali
+namespace Dali
{
DALI_ACTOR_EVENTHANDLER_PARAM( Dali, Actor);
}
*/
%define Animation_EVENTHANDLER_TYPEMAP_EVENTARG(NameSpace, ClassName)
- %typemap(csimports) NameSpace::ClassName %{
- using System;
- using System.Runtime.InteropServices;
+%typemap(csimports) NameSpace::ClassName %{
+using System;
+using System.Runtime.InteropServices;
+%}
- %}
- %enddef
+%enddef
%define Animation_EVENTHANDLER_TYPEMAP_HELPER(NameSpace, ClassName)
%typemap(cscode) NameSpace::ClassName %{
-
/**
* @brief Event arguments that passed via Finished signal
*
}
- public static ClassName Get ## ClassName ## FromPtr(global::System.IntPtr cPtr) {
- ClassName ret = new ClassName(cPtr, false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
+ public static ClassName Get ## ClassName ## FromPtr(global::System.IntPtr cPtr) {
+ ClassName ret = new ClassName(cPtr, false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+
+ public float Duration
+ {
+ set
+ {
+ SetDuration(value);
+ }
+ get
+ {
+ float ret = GetDuration();
+ return ret;
+ }
+ }
+
+ public AlphaFunction DefaultAlphaFunction
+ {
+ set
+ {
+ SetDefaultAlphaFunction(value);
+ }
+ get
+ {
+ AlphaFunction ret = GetDefaultAlphaFunction();
+ return ret;
+ }
+ }
+
+ public Animation.State Status
+ {
+ get
+ {
+ Animation.State ret = GetState();
+ return ret;
}
+ }
- %}
+%}
- %enddef
+%enddef
%define DALI_animation_EVENTHANDLER_PARAM( NameSpace, ClassName)
// Example from Swig MACRO
-%define EVENTHANDLER_TYPEMAP_EVENTARG(NameSpace, ClassName)
+%define BUTTON_EVENTHANDLER_TYPEMAP_EVENTARG(NameSpace, ClassName)
%typemap(csimports) NameSpace::ClassName %{
using System;
using System.Runtime.InteropServices;
%enddef
-%define EVENTHANDLER_TYPEMAP_HELPER(NameSpace, ClassName)
+%define BUTTON_EVENTHANDLER_TYPEMAP_HELPER(NameSpace, ClassName)
%typemap(cscode) NameSpace::ClassName %{
public class ClickedEventArgs : EventArgs
// Callback for button click signal
private bool OnClicked (IntPtr data)
{
- Button##ClickedEventArgs e = new ClickedEventArgs();
+ ClickedEventArgs e = new ClickedEventArgs();
e.Button = Button.GetButtonFromPtr(data);
// Callback for button click signal
private bool OnPressed (IntPtr data)
{
- Button##PressedEventArgs e = new PressedEventArgs();
+ PressedEventArgs e = new PressedEventArgs();
e.Button = Button.GetButtonFromPtr(data);
// Callback for button click signal
private bool OnReleased (IntPtr data)
{
- Button##ReleasedEventArgs e = new ReleasedEventArgs();
+ ReleasedEventArgs e = new ReleasedEventArgs();
e.Button = Button.GetButtonFromPtr(data);
// Callback for button click signal
private bool OnStateChanged (IntPtr data)
{
- Button##StateChangedEventArgs e = new StateChangedEventArgs();
+ StateChangedEventArgs e = new StateChangedEventArgs();
e.Button = Button.GetButtonFromPtr(data);
*/
public class KeyInputFocusGainedEventArgs : EventArgs
{
- private Control _control;
+ private View _view;
/**
- * @brief Control - is the control that gets Key Input Focus
+ * @brief View - is the view that gets Key Input Focus
*
*/
- public Control Control
+ public View View
{
get
{
- return _control;
+ return _view;
}
set
{
- _control = value;
+ _view = value;
}
}
}
*/
public class KeyInputFocusLostEventArgs : EventArgs
{
- private Control _control;
+ private View _view;
/**
- * @brief Control - is the control that loses Key Input Focus
+ * @brief View - is the view that loses Key Input Focus
*
*/
- public Control Control
+ public View View
{
get
{
- return _control;
+ return _view;
}
set
{
- _control = value;
+ _view = value;
}
}
}
*/
public class KeyEventArgs : EventArgs
{
- private Control _control;
+ private View _view;
private KeyEvent _keyEvent;
/**
- * @brief Control - is the control that recieves the keyevent.
+ * @brief View - is the view that recieves the keyevent.
*
*/
- public Control Control
+ public View View
{
get
{
- return _control;
+ return _view;
}
set
{
- _control = value;
+ _view = value;
}
}
/**
- * @brief KeyEvent - is the keyevent sent to the Control.
+ * @brief KeyEvent - is the keyevent sent to the View.
*
*/
public KeyEvent KeyEvent
public delegate bool KeyEventHandler(object source, KeyEventArgs e);
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
- private delegate void KeyInputFocusGainedCallbackDelegate(IntPtr control);
+ private delegate void KeyInputFocusGainedCallbackDelegate(IntPtr view);
private KeyInputFocusGainedEventHandler _KeyInputFocusGainedEventHandler;
private KeyInputFocusGainedCallbackDelegate _KeyInputFocusGainedCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
- private delegate void KeyInputFocusLostCallbackDelegate(IntPtr control);
+ private delegate void KeyInputFocusLostCallbackDelegate(IntPtr view);
private KeyInputFocusLostEventHandler _KeyInputFocusLostEventHandler;
private KeyInputFocusLostCallbackDelegate _KeyInputFocusLostCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
- private delegate bool KeyCallbackDelegate(IntPtr control, IntPtr keyEvent);
+ private delegate bool KeyCallbackDelegate(IntPtr view, IntPtr keyEvent);
private KeyEventHandler _KeyEventHandler;
private KeyCallbackDelegate _KeyCallbackDelegate;
/**
* @brief Event for KeyInputFocusGained signal which can be used to subscribe/unsubscribe the event handler
* (in the type of KeyInputFocusGainedEventHandler) provided by the user.
- * KeyInputFocusGained signal is emitted when the control gets Key Input Focus.
+ * KeyInputFocusGained signal is emitted when the view gets Key Input Focus.
*/
public event KeyInputFocusGainedEventHandler KeyInputFocusGained
{
}
}
- private void OnKeyInputFocusGained(IntPtr control)
+ private void OnKeyInputFocusGained(IntPtr view)
{
KeyInputFocusGainedEventArgs e = new KeyInputFocusGainedEventArgs();
// Populate all members of "e" (KeyInputFocusGainedEventArgs) with real data
- e.Control = Dali.Control.GetControlFromPtr(control);
+ e.View = Dali.View.GetViewFromPtr(view);
if (_KeyInputFocusGainedEventHandler != null)
{
/**
* @brief Event for KeyInputFocusLost signal which can be used to subscribe/unsubscribe the event handler
* (in the type of KeyInputFocusLostEventHandler) provided by the user.
- * KeyInputFocusLost signal is emitted when the control loses Key Input Focus.
+ * KeyInputFocusLost signal is emitted when the view loses Key Input Focus.
*/
public event KeyInputFocusLostEventHandler KeyInputFocusLost
{
}
}
- private void OnKeyInputFocusLost(IntPtr control)
+ private void OnKeyInputFocusLost(IntPtr view)
{
KeyInputFocusLostEventArgs e = new KeyInputFocusLostEventArgs();
// Populate all members of "e" (KeyInputFocusLostEventArgs) with real data
- e.Control = Dali.Control.GetControlFromPtr(control);
+ e.View = Dali.View.GetViewFromPtr(view);
if (_KeyInputFocusLostEventHandler != null)
{
}
}
- private bool OnKeyEvent(IntPtr control, IntPtr keyEvent)
+ private bool OnKeyEvent(IntPtr view, IntPtr keyEvent)
{
KeyEventArgs e = new KeyEventArgs();
// Populate all members of "e" (KeyEventArgs) with real data
- e.Control = Dali.Control.GetControlFromPtr(control);
- e.KeyEvent = Dali.KeyEvent.GetKeyEventFromPtr(keyEvent);
+ e.View = Dali.View.GetViewFromPtr(view);
+ e.KeyEvent = Dali.KeyEvent.GetKeyEventFromPtr(keyEvent);
if (_KeyEventHandler != null)
{
}
- public static ClassName Get ## ClassName ## FromPtr(global::System.IntPtr cPtr) {
- ClassName ret = new ClassName(cPtr, false);
+ public static View GetViewFromPtr(global::System.IntPtr cPtr) {
+ View ret = new View(cPtr, false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
}
}
+ public Vector2 Size
+ {
+ get
+ {
+ Vector2 ret = GetSize();
+ return ret;
+ }
+ }
+
+ public Vector4 BackgroundColor
+ {
+ set
+ {
+ SetBackgroundColor(value);
+ }
+ get
+ {
+ Vector4 ret = GetBackgroundColor();
+ return ret;
+ }
+ }
+
%}
%enddef
// Signal< bool ( Dali::Toolkit::AccessibilityManager&, const Dali::TouchEvent& ) >
DALI_SIGNAL_2_PARAM_RETURN( bool ,Dali::Toolkit::AccessibilityManager&, const Dali::TouchEvent&);
-// Signal< void ( Dali::Actor, Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >
-//DALI_SIGNAL_2_PARAM( Dali::Actor, Dali::Toolkit::AccessibilityManager::FocusOvershotDirection );
-
// Signal< void ( Dali::Toolkit::StyleManager, Dali::StyleChange::Type) >
DALI_SIGNAL_2_PARAM( Dali::Toolkit::StyleManager, Dali::StyleChange::Type);
-// Signal< void ( Dali::Actor, Dali::Toolkit::AccessibilityManager::FocusOvershotDirection )>
-//DALI_SIGNAL_2_PARAM( Dali::Actor, Dali::Toolkit::AccessibilityManager::FocusOvershotDirection );
-
-// Signal< Dali::Actor ( Dali::Actor, Dali::Actor, Dali::Actor, Dali::Toolkit::Control::KeyboardFocus::Direction) >
-DALI_SIGNAL_3_PARAM_RETURN( Dali::Actor, Dali::Actor, Dali::Actor, Dali::Toolkit::Control::KeyboardFocus::Direction);
-
// void Signal< Dali::Actor, bool >;
DALI_SIGNAL_2_PARAM( Dali::Actor, bool);
fullPath = pn.to_s
$rootPath = fullPath.slice(0..( fullPath.index('/dali-toolkit')))
- $daliCSharpPath = $rootPath + "dali-toolkit/plugins/dali-swig/csharp"
+ $daliCSharpPath = $rootPath + "dali-toolkit/plugins/dali-swig/automatic/csharp"
puts("--------------------------------------------")
puts("Modifying constructors for DALi C# files ")
puts("E.g. modify TextLabel::New() ==> new TextLabel() ")
Console.WriteLine("Actor name: " + actor.Name);
Stage stage = Stage.GetCurrent();
- stage.SetBackgroundColor( NDalic.WHITE );
+ stage.BackgroundColor = NDalic.WHITE ;
- Vector2 stageSize = stage.GetSize();
+ Vector2 stageSize = stage.Size;
Console.WriteLine("Stage size: " + stageSize.x + ", " + stageSize.y);
stage.Add(actor);
{
Console.WriteLine("Customized Application Initialize event handler");
Stage stage = Stage.GetCurrent();
- stage.SetBackgroundColor( NDalic.WHITE );
+ stage.BackgroundColor = NDalic.WHITE;
stage.Touched += new Dali.Stage.TouchEventHandler(OnStageTouched);
public void AnimationFinished(object source, Animation.FinishedEventArgs e)
{
Console.WriteLine("Customized Animation Finished Event handler");
- Console.WriteLine("Animation finished: duration = " + e.Animation.GetDuration());
+ Console.WriteLine("Animation finished: duration = " + e.Animation.Duration);
}
// Callback for stage touched signal handling
private void CreateScrollView()
{
Stage stage = Stage.GetCurrent();
- stage.SetBackgroundColor(NDalic.WHITE);
+ stage.BackgroundColor = NDalic.WHITE;
// Create a scroll view
_scrollView = new ScrollView();
- Vector2 stageSize = stage.GetSize();
+ Vector2 stageSize = stage.Size;
_scrollView.Size = new Vector3(stageSize.x, stageSize.y, 0.0f);
_scrollView.ParentOrigin = NDalic.ParentOriginCenter;
_scrollView.AnchorPoint = NDalic.AnchorPointCenter;
{
for(int pageColumn = 0; pageColumn < pageColumns; pageColumn++)
{
- Control pageActor = new Control();
+ View pageActor = new View();
pageActor.SetResizePolicy(ResizePolicyType.FILL_TO_PARENT, DimensionType.ALL_DIMENSIONS);
pageActor.ParentOrigin = NDalic.ParentOriginCenter;
pageActor.AnchorPoint = NDalic.AnchorPointCenter;
_scrollView.Add(_scrollBar);
// Connect to the OnRelayout signal
- _scrollView.OnRelayoutEvent += new Dali.Actor.OnRelayoutEventHandler(OnScrollViewRelayout);
+ _scrollView.OnRelayoutEvent += new Dali.View.OnRelayoutEventHandler(OnScrollViewRelayout);
}
- private void OnScrollViewRelayout(object source, Actor.OnRelayoutEventArgs e)
+ private void OnScrollViewRelayout(object source, View.OnRelayoutEventArgs e)
{
// Set the correct scroll bar size after size negotiation of scroll view is done
_scrollBar.Size = new Vector3(0.0f, _scrollView.GetRelayoutSize(DimensionType.WIDTH), 0.0f);
--- /dev/null
+#ifndef CSHARP_COMMON
+#define CSHARP_COMMON
+#endif
+
+#define SWIG_DIRECTORS
+
+#include <stdexcept>
+
+#define SWIGSTDCALL
+
+/* attribute recognised by some compilers to avoid 'unused' warnings */
+#ifndef SWIGUNUSED
+# if defined(__GNUC__)
+# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+# define SWIGUNUSED __attribute__ ((__unused__))
+# else
+# define SWIGUNUSED
+# endif
+# elif defined(__ICC)
+# define SWIGUNUSED __attribute__ ((__unused__))
+# else
+# define SWIGUNUSED
+# endif
+#endif
+
+/* internal SWIG method */
+#ifndef SWIGINTERN
+# define SWIGINTERN static SWIGUNUSED
+#endif
+
+#ifndef SWIGEXPORT
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+# if defined(STATIC_LINKED)
+# define SWIGEXPORT
+# else
+# define SWIGEXPORT __declspec(dllexport)
+# endif
+# else
+# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+# define SWIGEXPORT __attribute__ ((visibility("default")))
+# else
+# define SWIGEXPORT
+# endif
+# endif
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+/* Errors in SWIG */
+#define SWIG_UnknownError -1
+#define SWIG_IOError -2
+#define SWIG_RuntimeError -3
+#define SWIG_IndexError -4
+#define SWIG_TypeError -5
+#define SWIG_DivisionByZero -6
+#define SWIG_OverflowError -7
+#define SWIG_SyntaxError -8
+#define SWIG_ValueError -9
+#define SWIG_SystemError -10
+#define SWIG_AttributeError -11
+#define SWIG_MemoryError -12
+#define SWIG_NullReferenceError -13
+
+/* Support for throwing C# exceptions from C/C++. There are two types:
+ * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
+typedef enum {
+ SWIG_CSharpApplicationException,
+ SWIG_CSharpArithmeticException,
+ SWIG_CSharpDivideByZeroException,
+ SWIG_CSharpIndexOutOfRangeException,
+ SWIG_CSharpInvalidCastException,
+ SWIG_CSharpInvalidOperationException,
+ SWIG_CSharpIOException,
+ SWIG_CSharpNullReferenceException,
+ SWIG_CSharpOutOfMemoryException,
+ SWIG_CSharpOverflowException,
+ SWIG_CSharpSystemException
+} SWIG_CSharpExceptionCodes;
+
+typedef enum {
+ SWIG_CSharpArgumentException,
+ SWIG_CSharpArgumentNullException,
+ SWIG_CSharpArgumentOutOfRangeException
+} SWIG_CSharpExceptionArgumentCodes;
+
+typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
+typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);
+
+typedef struct {
+ SWIG_CSharpExceptionCodes code;
+ SWIG_CSharpExceptionCallback_t callback;
+} SWIG_CSharpException_t;
+
+typedef struct {
+ SWIG_CSharpExceptionArgumentCodes code;
+ SWIG_CSharpExceptionArgumentCallback_t callback;
+} SWIG_CSharpExceptionArgument_t;
+
+static SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
+ { SWIG_CSharpApplicationException, NULL },
+ { SWIG_CSharpArithmeticException, NULL },
+ { SWIG_CSharpDivideByZeroException, NULL },
+ { SWIG_CSharpIndexOutOfRangeException, NULL },
+ { SWIG_CSharpInvalidCastException, NULL },
+ { SWIG_CSharpInvalidOperationException, NULL },
+ { SWIG_CSharpIOException, NULL },
+ { SWIG_CSharpNullReferenceException, NULL },
+ { SWIG_CSharpOutOfMemoryException, NULL },
+ { SWIG_CSharpOverflowException, NULL },
+ { SWIG_CSharpSystemException, NULL }
+};
+
+static SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
+ { SWIG_CSharpArgumentException, NULL },
+ { SWIG_CSharpArgumentNullException, NULL },
+ { SWIG_CSharpArgumentOutOfRangeException, NULL }
+};
+
+static void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
+ SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
+ if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
+ callback = SWIG_csharp_exceptions[code].callback;
+ }
+ callback(msg);
+}
+
+static void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
+ SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
+ if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
+ callback = SWIG_csharp_exceptions_argument[code].callback;
+ }
+ callback(msg, param_name);
+}
+
+SWIGINTERN void SWIG_CSharpException(int code, const char *msg) {
+ if (code == SWIG_ValueError) {
+ SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
+ SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
+ } else {
+ SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
+ switch(code) {
+ case SWIG_MemoryError:
+ exception_code = SWIG_CSharpOutOfMemoryException;
+ break;
+ case SWIG_IndexError:
+ exception_code = SWIG_CSharpIndexOutOfRangeException;
+ break;
+ case SWIG_DivisionByZero:
+ exception_code = SWIG_CSharpDivideByZeroException;
+ break;
+ case SWIG_IOError:
+ exception_code = SWIG_CSharpIOException;
+ break;
+ case SWIG_OverflowError:
+ exception_code = SWIG_CSharpOverflowException;
+ break;
+ case SWIG_RuntimeError:
+ case SWIG_TypeError:
+ case SWIG_SyntaxError:
+ case SWIG_SystemError:
+ case SWIG_UnknownError:
+ default:
+ exception_code = SWIG_CSharpApplicationException;
+ break;
+ }
+ SWIG_CSharpSetPendingException(exception_code, msg);
+ }
+}
+
+
+#include <stdexcept>
+
+
+#define SWIGSTDCALL
+
+
+#include <dali/dali.h>
+#include <dali-toolkit/dali-toolkit.h>
+
+using namespace Dali;
+using namespace Dali::Toolkit;
+
+
--- /dev/null
+#ifndef CSHARP_KEYBOARD_FOCUS_MANAGER
+#define CSHARP_KEYBOARD_FOCUS_MANAGER
+#endif
+
+#include "common.h"
+
+SWIGINTERN bool Dali_Signal_Sl_Dali_Actor_Sp_Dali_Actor_Sc_Dali_Actor_Sc_Dali_Toolkit_Control_KeyboardFocus_Direction_SP__Sg__Empty(Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > const *self){
+ return self->Empty();
+ }
+SWIGINTERN std::size_t Dali_Signal_Sl_Dali_Actor_Sp_Dali_Actor_Sc_Dali_Actor_Sc_Dali_Toolkit_Control_KeyboardFocus_Direction_SP__Sg__GetConnectionCount(Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > const *self){
+ return self->GetConnectionCount();
+ }
+SWIGINTERN void Dali_Signal_Sl_Dali_Actor_Sp_Dali_Actor_Sc_Dali_Actor_Sc_Dali_Toolkit_Control_KeyboardFocus_Direction_SP__Sg__Connect(Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *self,Dali::Actor (*func)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction)){
+ return self->Connect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_Dali_Actor_Sp_Dali_Actor_Sc_Dali_Actor_Sc_Dali_Toolkit_Control_KeyboardFocus_Direction_SP__Sg__Disconnect(Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *self,Dali::Actor (*func)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction)){
+ self->Disconnect( func );
+ }
+SWIGINTERN Dali::Actor Dali_Signal_Sl_Dali_Actor_Sp_Dali_Actor_Sc_Dali_Actor_Sc_Dali_Toolkit_Control_KeyboardFocus_Direction_SP__Sg__Emit(Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *self,Dali::Actor arg1,Dali::Actor arg2,Dali::Toolkit::Control::KeyboardFocus::Direction arg3){
+ return self->Emit( arg1, arg2, arg3 );
+ }
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_new_KeyboardFocusManager() {
+ void * jresult;
+ Dali::Toolkit::KeyboardFocusManager *result = 0 ;
+
+ {
+ try {
+ result = (Dali::Toolkit::KeyboardFocusManager *)new Dali::Toolkit::KeyboardFocusManager();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_delete_KeyboardFocusManager(void * jarg1) {
+ Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
+
+ arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
+ {
+ try {
+ delete arg1;
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+ };
+ }
+ }
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardFocusManager_Get() {
+ void * jresult;
+ Dali::Toolkit::KeyboardFocusManager result;
+
+ {
+ try {
+ result = Dali::Toolkit::KeyboardFocusManager::Get();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = new Dali::Toolkit::KeyboardFocusManager((const Dali::Toolkit::KeyboardFocusManager &)result);
+ return jresult;
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_KeyboardFocusManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
+ unsigned int jresult ;
+ Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
+ Dali::Actor arg2;
+ Dali::Actor *argp2 ;
+ bool result;
+
+ arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
+ argp2 = (Dali::Actor *)jarg2;
+ if (!argp2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
+ return 0;
+ }
+ arg2 = *argp2;
+ {
+ try {
+ result = (bool)(arg1)->SetCurrentFocusActor(arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardFocusManager_GetCurrentFocusActor(void * jarg1) {
+ void * jresult ;
+ Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
+ Dali::Actor result;
+
+ arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
+ {
+ try {
+ result = (arg1)->GetCurrentFocusActor();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = new Dali::Actor((const Dali::Actor &)result);
+ return jresult;
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_KeyboardFocusManager_MoveFocus(void * jarg1, int jarg2) {
+ unsigned int jresult ;
+ Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
+ Dali::Toolkit::Control::KeyboardFocus::Direction arg2;
+ bool result;
+
+ arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
+ arg2 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg2;
+ {
+ try {
+ result = (bool)(arg1)->MoveFocus(arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_KeyboardFocusManager_ClearFocus(void * jarg1) {
+ Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
+
+ arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
+ {
+ try {
+ (arg1)->ClearFocus();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
+ };
+ }
+ }
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_KeyboardFocusManager_SetFocusGroupLoop(void * jarg1, unsigned int jarg2) {
+ Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0;
+ bool arg2;
+
+ arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
+ arg2 = jarg2 ? true : false;
+ {
+ try {
+ (arg1)->SetFocusGroupLoop(arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+ };
+ }
+ }
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_KeyboardFocusManager_GetFocusGroupLoop(void * jarg1) {
+ unsigned int jresult ;
+ Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
+ bool result;
+
+ arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
+ {
+ try {
+ result = (bool)((Dali::Toolkit::KeyboardFocusManager const *)arg1)->GetFocusGroupLoop();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_KeyboardFocusManager_SetAsFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
+ Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
+ Dali::Actor arg2 ;
+ bool arg3 ;
+ Dali::Actor *argp2 ;
+
+ arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
+ argp2 = (Dali::Actor *)jarg2;
+ if (!argp2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
+ return ;
+ }
+ arg2 = *argp2;
+ arg3 = jarg3 ? true : false;
+ {
+ try {
+ (arg1)->SetAsFocusGroup(arg2,arg3);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+ };
+ }
+ }
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_KeyboardFocusManager_IsFocusGroup(void * jarg1, void * jarg2) {
+ unsigned int jresult ;
+ Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
+ Dali::Actor arg2 ;
+ Dali::Actor *argp2 ;
+ bool result;
+
+ arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
+ argp2 = (Dali::Actor *)jarg2;
+ if (!argp2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
+ return 0;
+ }
+ arg2 = *argp2;
+ {
+ try {
+ result = (bool)((Dali::Toolkit::KeyboardFocusManager const *)arg1)->IsFocusGroup(arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardFocusManager_GetFocusGroup(void * jarg1, void * jarg2) {
+ void * jresult ;
+ Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
+ Dali::Actor arg2 ;
+ Dali::Actor *argp2 ;
+ Dali::Actor result;
+
+ arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
+ argp2 = (Dali::Actor *)jarg2;
+ if (!argp2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
+ return 0;
+ }
+ arg2 = *argp2;
+ {
+ try {
+ result = (arg1)->GetFocusGroup(arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = new Dali::Actor((const Dali::Actor &)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_KeyboardFocusManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
+ Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
+ Dali::Actor arg2 ;
+ Dali::Actor *argp2 ;
+
+ arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
+ argp2 = (Dali::Actor *)jarg2;
+ if (!argp2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
+ return ;
+ }
+ arg2 = *argp2;
+ {
+ try {
+ (arg1)->SetFocusIndicatorActor(arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+ };
+ }
+ }
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardFocusManager_GetFocusIndicatorActor(void * jarg1) {
+ void * jresult ;
+ Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
+ Dali::Actor result;
+
+ arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
+ {
+ try {
+ result = (arg1)->GetFocusIndicatorActor();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = new Dali::Actor((const Dali::Actor &)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardFocusManager_PreFocusChangeSignal(void * jarg1) {
+ void * jresult ;
+ Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
+ Dali::Toolkit::KeyboardFocusManager::PreFocusChangeSignalType *result = 0 ;
+
+ arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
+ {
+ try {
+ result = (Dali::Toolkit::KeyboardFocusManager::PreFocusChangeSignalType *) &(arg1)->PreFocusChangeSignal();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardFocusManager_FocusChangedSignal(void * jarg1) {
+ void * jresult ;
+ Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
+ Dali::Toolkit::KeyboardFocusManager::FocusChangedSignalType *result = 0 ;
+
+ arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
+ {
+ try {
+ result = (Dali::Toolkit::KeyboardFocusManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardFocusManager_FocusGroupChangedSignal(void * jarg1) {
+ void * jresult ;
+ Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
+ Dali::Toolkit::KeyboardFocusManager::FocusGroupChangedSignalType *result = 0 ;
+
+ arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
+ {
+ try {
+ result = (Dali::Toolkit::KeyboardFocusManager::FocusGroupChangedSignalType *) &(arg1)->FocusGroupChangedSignal();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardFocusManager_FocusedActorEnterKeySignal(void * jarg1) {
+ void * jresult ;
+ Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
+ Dali::Toolkit::KeyboardFocusManager::FocusedActorEnterKeySignalType *result = 0 ;
+
+ arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
+ {
+ try {
+ result = (Dali::Toolkit::KeyboardFocusManager::FocusedActorEnterKeySignalType *) &(arg1)->FocusedActorEnterKeySignal();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_KeyboardPreFocusChangeSignal_Empty(void * jarg1) {
+ unsigned int jresult ;
+ Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *) 0 ;
+ bool result;
+
+ arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *)jarg1;
+ {
+ try {
+ result = (bool)Dali_Signal_Sl_Dali_Actor_Sp_Dali_Actor_Sc_Dali_Actor_Sc_Dali_Toolkit_Control_KeyboardFocus_Direction_SP__Sg__Empty((Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > const *)arg1);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_KeyboardPreFocusChangeSignal_GetConnectionCount(void * jarg1) {
+ unsigned long jresult ;
+ Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *) 0 ;
+ std::size_t result;
+
+ arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *)jarg1;
+ {
+ try {
+ result = Dali_Signal_Sl_Dali_Actor_Sp_Dali_Actor_Sc_Dali_Actor_Sc_Dali_Toolkit_Control_KeyboardFocus_Direction_SP__Sg__GetConnectionCount((Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > const *)arg1);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (unsigned long)result;
+ return jresult;
+}
+
+typedef void* (SWIGSTDCALL* SWIG_CallbackKbPreFocusChange)(void *, void *, int);
+SWIG_CallbackKbPreFocusChange swig_callbackOnKbPreFocusChange;
+
+Dali::Actor OnKbPreFocusChangeCallback(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction)
+{
+ Dali::Actor *actorp;
+ Dali::Actor actor;
+
+ actorp = (Dali::Actor *)swig_callbackOnKbPreFocusChange((void *)¤t, (void *)&proposed, direction);
+ actor = *actorp;
+
+ return actor;
+}
+
+SWIGEXPORT void SWIGSTDCALL CSharp_KeyboardPreFocusChangeSignal_Connect(void * jarg1, SWIG_CallbackKbPreFocusChange callbackOnKbPreFocusChange) {
+
+ swig_callbackOnKbPreFocusChange = callbackOnKbPreFocusChange;
+
+ Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *) 0 ;
+ Dali::Actor (*arg2)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) = (Dali::Actor (*)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction)) 0 ;
+
+ arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *)jarg1;
+ arg2 = (Dali::Actor (*)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction))OnKbPreFocusChangeCallback;
+
+ {
+ try {
+ Dali_Signal_Sl_Dali_Actor_Sp_Dali_Actor_Sc_Dali_Actor_Sc_Dali_Toolkit_Control_KeyboardFocus_Direction_SP__Sg__Connect(arg1,arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+ };
+ }
+ }
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_KeyboardPreFocusChangeSignal_Disconnect(void * jarg1, void * jarg2) {
+ Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *) 0 ;
+ Dali::Actor (*arg2)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) = (Dali::Actor (*)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction)) 0 ;
+
+ arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *)jarg1;
+ arg2 = (Dali::Actor (*)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction))jarg2;
+ {
+ try {
+ Dali_Signal_Sl_Dali_Actor_Sp_Dali_Actor_Sc_Dali_Actor_Sc_Dali_Toolkit_Control_KeyboardFocus_Direction_SP__Sg__Disconnect(arg1,arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+ };
+ }
+ }
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardPreFocusChangeSignal_Emit(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
+ void * jresult ;
+ Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *) 0 ;
+ Dali::Actor arg2 ;
+ Dali::Actor arg3 ;
+ Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
+ Dali::Actor *argp2 ;
+ Dali::Actor *argp3 ;
+ Dali::Actor result;
+
+ arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *)jarg1;
+ argp2 = (Dali::Actor *)jarg2;
+ if (!argp2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
+ return 0;
+ }
+ arg2 = *argp2;
+ argp3 = (Dali::Actor *)jarg3;
+ if (!argp3) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
+ return 0;
+ }
+ arg3 = *argp3;
+ arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
+ {
+ try {
+ result = Dali_Signal_Sl_Dali_Actor_Sp_Dali_Actor_Sc_Dali_Actor_Sc_Dali_Toolkit_Control_KeyboardFocus_Direction_SP__Sg__Emit(arg1,arg2,arg3,arg4);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = new Dali::Actor((const Dali::Actor &)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_new_KeyboardPreFocusChangeSignal() {
+ void * jresult ;
+ Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *result = 0 ;
+
+ {
+ try {
+ result = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *)new Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) >();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_delete_KeyboardPreFocusChangeSignal(void * jarg1) {
+ Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *) 0 ;
+
+ arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *)jarg1;
+ {
+ try {
+ delete arg1;
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+ };
+ }
+ }
+}
+
+SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_KeyboardFocusManager_SWIGUpcast(Dali::Toolkit::KeyboardFocusManager *jarg1) {
+ return (Dali::BaseHandle *)jarg1;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
--- /dev/null
+namespace Dali {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class KeyboardFocusManager : BaseHandle {
+ private global::System.Runtime.InteropServices.HandleRef swigCPtr;
+
+ internal KeyboardFocusManager(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicManualPINVOKE.KeyboardFocusManager_SWIGUpcast(cPtr), cMemoryOwn) {
+ swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
+ }
+
+ internal static global::System.Runtime.InteropServices.HandleRef getCPtr(KeyboardFocusManager obj) {
+ return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
+ }
+
+ ~KeyboardFocusManager() {
+ Dispose();
+ }
+
+ public override void Dispose() {
+ lock(this) {
+ if (swigCPtr.Handle != global::System.IntPtr.Zero) {
+ if (swigCMemOwn) {
+ swigCMemOwn = false;
+ NDalicManualPINVOKE.delete_KeyboardFocusManager(swigCPtr);
+ }
+ swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
+ }
+ global::System.GC.SuppressFinalize(this);
+ base.Dispose();
+ }
+ }
+
+
+/**
+ * @brief Event arguments that passed via FocusChanged signal
+ *
+ */
+public class FocusChangedEventArgs : EventArgs
+{
+ private Actor _actorCurrent;
+ private Actor _actorNext;
+
+ /**
+ * @brief Actor - is the original focused Actor
+ *
+ */
+ public Actor ActorCurrent
+ {
+ get
+ {
+ return _actorCurrent;
+ }
+ set
+ {
+ _actorCurrent = value;
+ }
+ }
+
+ /**
+ * @brief Actor - is the current focused Actor
+ *
+ */
+ public Actor ActorNext
+ {
+ get
+ {
+ return _actorNext;
+ }
+ set
+ {
+ _actorNext = value;
+ }
+ }
+}
+
+/**
+ * @brief Event arguments that passed via FocusGroupChanged signal
+ *
+ */
+public class FocusGroupChangedEventArgs : EventArgs
+{
+ private Actor _currentFocusedActor;
+ private bool _forwardDirection;
+
+ /**
+ * @brief Actor - is the current focused Actor
+ *
+ */
+ public Actor CurrentFocusedActor
+ {
+ get
+ {
+ return _currentFocusedActor;
+ }
+ set
+ {
+ _currentFocusedActor = value;
+ }
+ }
+
+ /**
+ * @brief ForwardDirection - is the direction (forward or backward) in which to move the focus next
+ *
+ */
+ public bool ForwardDirection
+ {
+ get
+ {
+ return _forwardDirection;
+ }
+ set
+ {
+ _forwardDirection = value;
+ }
+ }
+}
+
+/**
+ * @brief Event arguments that passed via FocusedActorEnterKey signal
+ *
+ */
+public class FocusedActorEnterKeyEventArgs : EventArgs
+{
+ private Actor _actor;
+
+ /**
+ * @brief Actor - is the current focused Actor which has the enter key pressed on it.
+ *
+ */
+ public Actor Actor
+ {
+ get
+ {
+ return _actor;
+ }
+ set
+ {
+ _actor = value;
+ }
+ }
+}
+
+/**
+ * @brief Event arguments that passed via PreFocusChange signal
+ *
+ */
+public class PreFocusChangeEventArgs : EventArgs
+{
+ private Actor _current;
+ private Actor _proposed;
+ private View.KeyboardFocus.Direction _direction;
+
+ /**
+ * @brief Actor - is the current focused Actor.
+ *
+ */
+ public Actor Current
+ {
+ get
+ {
+ return _current;
+ }
+ set
+ {
+ _current = value;
+ }
+ }
+
+ /**
+ * @brief Actor - is the proposed focused Actor.
+ *
+ */
+ public Actor Proposed
+ {
+ get
+ {
+ return _proposed;
+ }
+ set
+ {
+ _proposed = value;
+ }
+ }
+
+ /**
+ * @brief Direction - is the direction of Focus change.
+ *
+ */
+ public View.KeyboardFocus.Direction Direction
+ {
+ get
+ {
+ return _direction;
+ }
+ set
+ {
+ _direction = value;
+ }
+ }
+}
+
+ [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ public delegate void FocusChangedEventHandler(object source, FocusChangedEventArgs e);
+
+ [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ public delegate void FocusGroupChangedEventHandler(object source, FocusGroupChangedEventArgs e);
+
+ [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ public delegate void FocusedActorEnterKeyEventHandler(object source, FocusedActorEnterKeyEventArgs e);
+
+ [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ public delegate Actor PreFocusChangeEventHandler(object source, PreFocusChangeEventArgs e);
+
+ [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ public delegate IntPtr PreFocusChangeEventCallbackDelegate(IntPtr current, IntPtr proposed, View.KeyboardFocus.Direction direction);
+ private PreFocusChangeEventHandler _keyboardFocusManagerPreFocusChangeEventHandler;
+ private PreFocusChangeEventCallbackDelegate _keyboardFocusManagerPreFocusChangeEventCallbackDelegate;
+
+ [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ private delegate void FocusChangedEventCallbackDelegate(IntPtr actorCurrent, IntPtr actorNext);
+ private FocusChangedEventHandler _keyboardFocusManagerFocusChangedEventHandler;
+ private FocusChangedEventCallbackDelegate _keyboardFocusManagerFocusChangedEventCallbackDelegate;
+
+ [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ private delegate void FocusGroupChangedEventCallbackDelegate(IntPtr currentFocusedActor, bool forwardDirection);
+ private FocusGroupChangedEventHandler _keyboardFocusManagerFocusGroupChangedEventHandler;
+ private FocusGroupChangedEventCallbackDelegate _keyboardFocusManagerFocusGroupChangedEventCallbackDelegate;
+
+ [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ private delegate void FocusedActorEnterKeyEventCallbackDelegate(IntPtr actor);
+ private FocusedActorEnterKeyEventHandler _keyboardFocusManagerFocusedActorEnterKeyEventHandler;
+ private FocusedActorEnterKeyEventCallbackDelegate _keyboardFocusManagerFocusedActorEnterKeyEventCallbackDelegate;
+
+ public event PreFocusChangeEventHandler PreFocusChange
+ {
+ add
+ {
+ lock(this)
+ {
+ // Restricted to only one listener
+ if (_keyboardFocusManagerPreFocusChangeEventHandler == null)
+ {
+ _keyboardFocusManagerPreFocusChangeEventHandler += value;
+
+ _keyboardFocusManagerPreFocusChangeEventCallbackDelegate = new PreFocusChangeEventCallbackDelegate(OnPreFocusChange);
+ this.PreFocusChangeSignal().Connect(_keyboardFocusManagerPreFocusChangeEventCallbackDelegate);
+ }
+ }
+ }
+
+ remove
+ {
+ lock(this)
+ {
+ if (_keyboardFocusManagerPreFocusChangeEventHandler != null)
+ {
+ this.PreFocusChangeSignal().Disconnect(_keyboardFocusManagerPreFocusChangeEventCallbackDelegate);
+ }
+
+ _keyboardFocusManagerPreFocusChangeEventHandler -= value;
+ }
+ }
+ }
+
+ // Callback for KeyboardFocusManager PreFocusChangeSignal
+ private IntPtr OnPreFocusChange(IntPtr current, IntPtr proposed, View.KeyboardFocus.Direction direction)
+ {
+ Actor actor = null;
+ PreFocusChangeEventArgs e = new PreFocusChangeEventArgs();
+
+ // Populate all members of "e" (PreFocusChangeEventArgs) with real data
+ e.Current = Actor.GetActorFromPtr(current);
+ e.Proposed = Actor.GetActorFromPtr(proposed);
+ e.Direction = direction;
+
+ if (_keyboardFocusManagerPreFocusChangeEventHandler != null)
+ {
+ //here we send all data to user event handlers
+ actor = _keyboardFocusManagerPreFocusChangeEventHandler(this, e);
+ }
+
+ return actor.GetPtrfromActor();
+ }
+
+ /**
+ * @brief Event for FocusChanged signal which can be used to subscribe/unsubscribe the event handler
+ * (in the type of FocusChangedEventHandler) provided by the user.
+ * FocusChanged signal is emitted after the current focused actor has been changed.
+ */
+ public event FocusChangedEventHandler FocusChanged
+ {
+ add
+ {
+ lock(this)
+ {
+ // Restricted to only one listener
+ if (_keyboardFocusManagerFocusChangedEventHandler == null)
+ {
+ _keyboardFocusManagerFocusChangedEventHandler += value;
+
+ _keyboardFocusManagerFocusChangedEventCallbackDelegate = new FocusChangedEventCallbackDelegate(OnFocusChanged);
+ this.FocusChangedSignal().Connect(_keyboardFocusManagerFocusChangedEventCallbackDelegate);
+ }
+ }
+ }
+
+ remove
+ {
+ lock(this)
+ {
+ if (_keyboardFocusManagerFocusChangedEventHandler != null)
+ {
+ this.FocusChangedSignal().Disconnect(_keyboardFocusManagerFocusChangedEventCallbackDelegate);
+ }
+
+ _keyboardFocusManagerFocusChangedEventHandler -= value;
+ }
+ }
+ }
+
+ // Callback for KeyboardFocusManager FocusChangedSignal
+ private void OnFocusChanged(IntPtr actorCurrent, IntPtr actorNext)
+ {
+ FocusChangedEventArgs e = new FocusChangedEventArgs();
+
+ // Populate all members of "e" (FocusChangedEventArgs) with real data
+ e.ActorCurrent = Actor.GetActorFromPtr(actorCurrent);
+ e.ActorNext = Actor.GetActorFromPtr(actorNext);
+
+ if (_keyboardFocusManagerFocusChangedEventHandler != null)
+ {
+ //here we send all data to user event handlers
+ _keyboardFocusManagerFocusChangedEventHandler(this, e);
+ }
+ }
+
+ /**
+ * @brief Event for FocusGroupChanged signal which can be used to subscribe/unsubscribe the event handler
+ * (in the type of FocusGroupChangedEventHandler) provided by the user.
+ * FocusGroupChanged signal is emitted when the focus group has been changed.
+ */
+ public event FocusGroupChangedEventHandler FocusGroupChanged
+ {
+ add
+ {
+ lock(this)
+ {
+ // Restricted to only one listener
+ if (_keyboardFocusManagerFocusGroupChangedEventHandler == null)
+ {
+ _keyboardFocusManagerFocusGroupChangedEventHandler += value;
+
+ _keyboardFocusManagerFocusGroupChangedEventCallbackDelegate = new FocusGroupChangedEventCallbackDelegate(OnFocusGroupChanged);
+ this.FocusGroupChangedSignal().Connect(_keyboardFocusManagerFocusGroupChangedEventCallbackDelegate);
+ }
+ }
+ }
+
+ remove
+ {
+ lock(this)
+ {
+ if (_keyboardFocusManagerFocusGroupChangedEventHandler != null)
+ {
+ this.FocusGroupChangedSignal().Disconnect(_keyboardFocusManagerFocusGroupChangedEventCallbackDelegate);
+ }
+
+ _keyboardFocusManagerFocusGroupChangedEventHandler -= value;
+ }
+ }
+ }
+
+ // Callback for KeyboardFocusManager FocusGroupChangedSignal
+ private void OnFocusGroupChanged(IntPtr currentFocusedActor, bool forwardDirection)
+ {
+ FocusGroupChangedEventArgs e = new FocusGroupChangedEventArgs();
+
+ // Populate all members of "e" (FocusGroupChangedEventArgs) with real data
+ e.CurrentFocusedActor = Actor.GetActorFromPtr(currentFocusedActor);
+ e.ForwardDirection = forwardDirection;
+
+ if (_keyboardFocusManagerFocusGroupChangedEventHandler != null)
+ {
+ //here we send all data to user event handlers
+ _keyboardFocusManagerFocusGroupChangedEventHandler(this, e);
+ }
+ }
+
+ /**
+ * @brief Event for FocusedActorEnterKeyPressed signal which can be used to subscribe/unsubscribe the event handler
+ * (in the type of FocusedActorEnterKeyEventHandler) provided by the user.
+ * FocusedActorEnterKeyPressed signal is emitted when the current focused actor has the enter key pressed on it.
+ */
+ public event FocusedActorEnterKeyEventHandler FocusedActorEnterKeyPressed
+ {
+ add
+ {
+ lock(this)
+ {
+ // Restricted to only one listener
+ if (_keyboardFocusManagerFocusedActorEnterKeyEventHandler == null)
+ {
+ _keyboardFocusManagerFocusedActorEnterKeyEventHandler += value;
+
+ _keyboardFocusManagerFocusedActorEnterKeyEventCallbackDelegate = new FocusedActorEnterKeyEventCallbackDelegate(OnFocusedActorEnterKey);
+ this.FocusedActorEnterKeySignal().Connect(_keyboardFocusManagerFocusedActorEnterKeyEventCallbackDelegate);
+ }
+ }
+ }
+
+ remove
+ {
+ lock(this)
+ {
+ if (_keyboardFocusManagerFocusedActorEnterKeyEventHandler != null)
+ {
+ this.FocusedActorEnterKeySignal().Disconnect(_keyboardFocusManagerFocusedActorEnterKeyEventCallbackDelegate);
+ }
+
+ _keyboardFocusManagerFocusedActorEnterKeyEventHandler -= value;
+ }
+ }
+ }
+
+ // Callback for KeyboardFocusManager FocusedActorEnterKeySignal
+ private void OnFocusedActorEnterKey(IntPtr actor)
+ {
+ FocusedActorEnterKeyEventArgs e = new FocusedActorEnterKeyEventArgs();
+
+ // Populate all members of "e" (FocusedActorEnterKeyEventArgs) with real data
+ e.Actor = Actor.GetActorFromPtr(actor);
+
+ if (_keyboardFocusManagerFocusedActorEnterKeyEventHandler != null)
+ {
+ //here we send all data to user event handlers
+ _keyboardFocusManagerFocusedActorEnterKeyEventHandler(this, e);
+ }
+ }
+
+ public KeyboardFocusManager() : this(NDalicManualPINVOKE.new_KeyboardFocusManager(), true) {
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public static KeyboardFocusManager Get() {
+ KeyboardFocusManager ret = new KeyboardFocusManager(NDalicManualPINVOKE.KeyboardFocusManager_Get(), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public bool SetCurrentFocusActor(Actor actor) {
+ bool ret = NDalicManualPINVOKE.KeyboardFocusManager_SetCurrentFocusActor(swigCPtr, Actor.getCPtr(actor));
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public Actor GetCurrentFocusActor() {
+ Actor ret = new Actor(NDalicManualPINVOKE.KeyboardFocusManager_GetCurrentFocusActor(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public bool MoveFocus(View.KeyboardFocus.Direction direction) {
+ bool ret = NDalicManualPINVOKE.KeyboardFocusManager_MoveFocus(swigCPtr, (int)direction);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void ClearFocus() {
+ NDalicManualPINVOKE.KeyboardFocusManager_ClearFocus(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void SetFocusGroupLoop(bool enabled) {
+ NDalicManualPINVOKE.KeyboardFocusManager_SetFocusGroupLoop(swigCPtr, enabled);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public bool GetFocusGroupLoop() {
+ bool ret = NDalicManualPINVOKE.KeyboardFocusManager_GetFocusGroupLoop(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void SetAsFocusGroup(Actor actor, bool isFocusGroup) {
+ NDalicManualPINVOKE.KeyboardFocusManager_SetAsFocusGroup(swigCPtr, Actor.getCPtr(actor), isFocusGroup);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public bool IsFocusGroup(Actor actor) {
+ bool ret = NDalicManualPINVOKE.KeyboardFocusManager_IsFocusGroup(swigCPtr, Actor.getCPtr(actor));
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public Actor GetFocusGroup(Actor actor) {
+ Actor ret = new Actor(NDalicManualPINVOKE.KeyboardFocusManager_GetFocusGroup(swigCPtr, Actor.getCPtr(actor)), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void SetFocusIndicatorActor(Actor indicator) {
+ NDalicManualPINVOKE.KeyboardFocusManager_SetFocusIndicatorActor(swigCPtr, Actor.getCPtr(indicator));
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public Actor GetFocusIndicatorActor() {
+ Actor ret = new Actor(NDalicManualPINVOKE.KeyboardFocusManager_GetFocusIndicatorActor(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public KeyboardPreFocusChangeSignal PreFocusChangeSignal() {
+ KeyboardPreFocusChangeSignal ret = new KeyboardPreFocusChangeSignal(NDalicManualPINVOKE.KeyboardFocusManager_PreFocusChangeSignal(swigCPtr), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public FocusChangedSignal FocusChangedSignal() {
+ FocusChangedSignal ret = new FocusChangedSignal(NDalicManualPINVOKE.KeyboardFocusManager_FocusChangedSignal(swigCPtr), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public FocusGroupChangedSignal FocusGroupChangedSignal() {
+ FocusGroupChangedSignal ret = new FocusGroupChangedSignal(NDalicManualPINVOKE.KeyboardFocusManager_FocusGroupChangedSignal(swigCPtr), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public ActorSignal FocusedActorEnterKeySignal() {
+ ActorSignal ret = new ActorSignal(NDalicManualPINVOKE.KeyboardFocusManager_FocusedActorEnterKeySignal(swigCPtr), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+}
+
+}
--- /dev/null
+using System;
+
+namespace Dali {
+
+public delegate IntPtr SwigDelegateKeyboardPreFocusChangeSignal(IntPtr current, IntPtr proposed, View.KeyboardFocus.Direction direction);
+
+public class KeyboardPreFocusChangeSignal : global::System.IDisposable {
+ private global::System.Runtime.InteropServices.HandleRef swigCPtr;
+ protected bool swigCMemOwn;
+
+ internal KeyboardPreFocusChangeSignal(global::System.IntPtr cPtr, bool cMemoryOwn) {
+ swigCMemOwn = cMemoryOwn;
+ swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
+ }
+
+ internal static global::System.Runtime.InteropServices.HandleRef getCPtr(KeyboardPreFocusChangeSignal obj) {
+ return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
+ }
+
+ ~KeyboardPreFocusChangeSignal() {
+ Dispose();
+ }
+
+ public virtual void Dispose() {
+ lock(this) {
+ if (swigCPtr.Handle != global::System.IntPtr.Zero) {
+ if (swigCMemOwn) {
+ swigCMemOwn = false;
+ NDalicManualPINVOKE.delete_KeyboardPreFocusChangeSignal(swigCPtr);
+ }
+ swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
+ }
+ global::System.GC.SuppressFinalize(this);
+ }
+ }
+
+ public bool Empty() {
+ bool ret = NDalicManualPINVOKE.KeyboardPreFocusChangeSignal_Empty(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public uint GetConnectionCount() {
+ uint ret = NDalicManualPINVOKE.KeyboardPreFocusChangeSignal_GetConnectionCount(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void Connect(KeyboardFocusManager.PreFocusChangeEventCallbackDelegate func) {
+ NDalicManualPINVOKE.KeyboardPreFocusChangeSignal_Connect(swigCPtr, func);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void Disconnect(System.Delegate func) {
+ System.IntPtr ip = System.Runtime.InteropServices.Marshal.GetFunctionPointerForDelegate(func);
+ {
+ NDalicManualPINVOKE.KeyboardPreFocusChangeSignal_Disconnect(swigCPtr, new System.Runtime.InteropServices.HandleRef(this, ip));
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+ }
+
+ public Actor Emit(Actor arg1, Actor arg2, View.KeyboardFocus.Direction arg3) {
+ Actor ret = new Actor(NDalicManualPINVOKE.KeyboardPreFocusChangeSignal_Emit(swigCPtr, Actor.getCPtr(arg1), Actor.getCPtr(arg2), (int)arg3), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public KeyboardPreFocusChangeSignal() : this(NDalicManualPINVOKE.new_KeyboardPreFocusChangeSignal(), true) {
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+}
+
+}
--- /dev/null
+namespace Dali {
+
+class NDalicManualPINVOKE {
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_new_KeyboardFocusManager")]
+ public static extern global::System.IntPtr new_KeyboardFocusManager();
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_delete_KeyboardFocusManager")]
+ public static extern void delete_KeyboardFocusManager(global::System.Runtime.InteropServices.HandleRef jarg1);
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_Get")]
+ public static extern global::System.IntPtr KeyboardFocusManager_Get();
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_SetCurrentFocusActor")]
+ public static extern bool KeyboardFocusManager_SetCurrentFocusActor(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_GetCurrentFocusActor")]
+ public static extern global::System.IntPtr KeyboardFocusManager_GetCurrentFocusActor(global::System.Runtime.InteropServices.HandleRef jarg1);
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_MoveFocus")]
+ public static extern bool KeyboardFocusManager_MoveFocus(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_ClearFocus")]
+ public static extern void KeyboardFocusManager_ClearFocus(global::System.Runtime.InteropServices.HandleRef jarg1);
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_SetFocusGroupLoop")]
+ public static extern void KeyboardFocusManager_SetFocusGroupLoop(global::System.Runtime.InteropServices.HandleRef jarg1, bool jarg2);
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_GetFocusGroupLoop")]
+ public static extern bool KeyboardFocusManager_GetFocusGroupLoop(global::System.Runtime.InteropServices.HandleRef jarg1);
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_SetAsFocusGroup")]
+ public static extern void KeyboardFocusManager_SetAsFocusGroup(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2, bool jarg3);
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_IsFocusGroup")]
+ public static extern bool KeyboardFocusManager_IsFocusGroup(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_GetFocusGroup")]
+ public static extern global::System.IntPtr KeyboardFocusManager_GetFocusGroup(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_SetFocusIndicatorActor")]
+ public static extern void KeyboardFocusManager_SetFocusIndicatorActor(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_GetFocusIndicatorActor")]
+ public static extern global::System.IntPtr KeyboardFocusManager_GetFocusIndicatorActor(global::System.Runtime.InteropServices.HandleRef jarg1);
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_PreFocusChangeSignal")]
+ public static extern global::System.IntPtr KeyboardFocusManager_PreFocusChangeSignal(global::System.Runtime.InteropServices.HandleRef jarg1);
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_FocusChangedSignal")]
+ public static extern global::System.IntPtr KeyboardFocusManager_FocusChangedSignal(global::System.Runtime.InteropServices.HandleRef jarg1);
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_FocusGroupChangedSignal")]
+ public static extern global::System.IntPtr KeyboardFocusManager_FocusGroupChangedSignal(global::System.Runtime.InteropServices.HandleRef jarg1);
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_FocusedActorEnterKeySignal")]
+ public static extern global::System.IntPtr KeyboardFocusManager_FocusedActorEnterKeySignal(global::System.Runtime.InteropServices.HandleRef jarg1);
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardPreFocusChangeSignal_Empty")]
+ public static extern bool KeyboardPreFocusChangeSignal_Empty(global::System.Runtime.InteropServices.HandleRef jarg1);
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardPreFocusChangeSignal_GetConnectionCount")]
+ public static extern uint KeyboardPreFocusChangeSignal_GetConnectionCount(global::System.Runtime.InteropServices.HandleRef jarg1);
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardPreFocusChangeSignal_Connect")]
+ public static extern void KeyboardPreFocusChangeSignal_Connect(global::System.Runtime.InteropServices.HandleRef jarg1, KeyboardFocusManager.PreFocusChangeEventCallbackDelegate delegate1);
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardPreFocusChangeSignal_Disconnect")]
+ public static extern void KeyboardPreFocusChangeSignal_Disconnect(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardPreFocusChangeSignal_Emit")]
+ public static extern global::System.IntPtr KeyboardPreFocusChangeSignal_Emit(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2, global::System.Runtime.InteropServices.HandleRef jarg3, int jarg4);
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_new_KeyboardPreFocusChangeSignal")]
+ public static extern global::System.IntPtr new_KeyboardPreFocusChangeSignal();
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_delete_KeyboardPreFocusChangeSignal")]
+ public static extern void delete_KeyboardPreFocusChangeSignal(global::System.Runtime.InteropServices.HandleRef jarg1);
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_SWIGUpcast")]
+ public static extern global::System.IntPtr KeyboardFocusManager_SWIGUpcast(global::System.IntPtr jarg1);
+
+}
+
+}
def writePropertiesToCSharpFile( daliClass )
# open the CSharp file autogenerated by SWIG
- swigFiles = $daliSwigPath + "/csharp/"
+ swigFiles = $daliSwigPath + "/automatic/csharp/"
fileName =(swigFiles+daliClass.name) + ".cs"
def writeChildPropertiesToCSharpFile( daliClass )
# open the CSharp file autogenerated by SWIG
- swigFiles = $daliSwigPath + "/csharp/"
+ swigFiles = $daliSwigPath + "/automatic/csharp/"
# Add all the child properties to Control
fileName = (swigFiles+"Control") + ".cs"
puts("Scanning folder: #{$daliCorePath}\n\n");
# Executed a recursive grep over dali-core for the DALI_PROPERTY macro
- result =`grep --include *.cpp -r "DALI_PROPERTY( \" #{$daliCorePath}`
+ result =`grep --include \\*.cpp -r "DALI_PROPERTY( \" #{$daliCorePath}`
# We now have a list of lines that look like this:
# DALI_PROPERTY_REGISTRATION
# DALI_ANIMATABLE_PROPERTY_REGISTRATION
# DALI_CHILD_PROPERTY_REGISTRATION
- result =`grep --include *.cpp -w 'Control::Impl::SetProperty\\|DALI_ANIMATABLE_PROPERTY_REGISTRATION_WITH_DEFAULT(\\|DALI_CHILD_PROPERTY_REGISTRATION(\\|DALI_ANIMATABLE_PROPERTY_REGISTRATION(\\|DALI_PROPERTY_REGISTRATION' -r #{$daliToolkitPath}`
+ result =`grep --include \\*.cpp -w 'Control::Impl::SetProperty\\|DALI_ANIMATABLE_PROPERTY_REGISTRATION_WITH_DEFAULT(\\|DALI_CHILD_PROPERTY_REGISTRATION(\\|DALI_ANIMATABLE_PROPERTY_REGISTRATION(\\|DALI_PROPERTY_REGISTRATION' -r #{$daliToolkitPath}`
if( result == "" )
puts("Error parsing #{$daliToolkitPath} no properties found")
+++ /dev/null
-swig -csharp -c++ -outdir ./csharp -namespace Dali -o ./cpp/dali_wrap.cpp ./SWIG/dali.i
projects / platform / core / uifw / dali-toolkit.git / commitdiff