$(dali_swig_dir)/automatic/cpp/dali_wrap.h
all-local:
-gbs-local: libNDalic.so NDali.dll
+gbs-local: libNDalic.so NDali.dll hello-world.exe
+
+hello-world.exe: $(dali_swig_dir)/NDali.dll
+ mcs -nologo -target:exe -out:$(dali_swig_dir)/hello-world.exe -reference:$(dali_swig_dir)/NDali.dll $(dali_swig_dir)/examples/hello-world.cs
libNDalic.so: $(dali_swig_dir)/automatic/cpp/dali_wrap.o $(dali_swig_dir)/manual/cpp/dali_wrap_manual.o
$(CXX) -shared $(dali_swig_dir)/automatic/cpp/dali_wrap.o $(dali_swig_dir)/manual/cpp/dali_wrap_manual.o -o $(dali_swig_dir)/libNDalic.so $(DALICORE_LIBS) $(DALIADAPTOR_LIBS) $(DALITOOLKIT_LIBS)
$(CXX) -c -fpic $(CXXFLAGS) $(DALICORE_CFLAGS) $(DALIADAPTOR_CFLAGS) $(DALITOOLKIT_CFLAGS) $(dali_swig_dir)/manual/cpp/keyboard_focus_manager_wrap.cpp -o $(dali_swig_dir)/manual/cpp/dali_wrap_manual.o
NDali.dll: $(BUILT_SOURCES)
-# mcs -nologo -target:library -out:$(dali_swig_dir)/NDali.dll $(dali_swig_dir)/automatic/csharp/*.cs $(dali_swig_dir)/manual/csharp/*.cs
+ mcs -nologo -target:library -out:$(dali_swig_dir)/NDali.dll $(dali_swig_dir)/automatic/csharp/*.cs $(dali_swig_dir)/manual/csharp/*.cs
$(BUILT_SOURCES): $(dali_swig_dir)/SWIG/*.i
- rm -f $(dali_swig_dir)/automatic/csharp/*.cs
- rm -f $(dali_swig_dir)/automatic/cpp/*.cpp
+# rm -f $(dali_swig_dir)/automatic/csharp/*.cs
+# rm -f $(dali_swig_dir)/automatic/cpp/*.cpp
$(SWIG) -version
$(SWIG) -csharp -c++ -outdir $(dali_swig_dir)/automatic/csharp \
$(DALI_CFLAGS) $(DALICORE_CFLAGS) $(DALIADAPTOR_CFLAGS) $(DALITOOLKIT_CFLAGS) -namespace Dali -o $(dali_swig_dir)/automatic/cpp/dali_wrap.cpp $(dali_swig_dir)/SWIG/dali.i
-$(INSTALL) -d $(DESTDIR)
-$(INSTALL) $(dali_swig_dir)/libNDalic.so $(DESTDIR)
-$(INSTALL) $(dali_swig_dir)/NDali.dll $(DESTDIR)
+ -$(INSTALL) $(dali_swig_dir)/hello-world.exe $(DESTDIR)
EXTRA_DIST = \
swig.cmd
--- /dev/null
+Name: NDalic
+Summary: dali wrapper
+Version: 1.2.14
+Release: 1
+Group: uifw/graphic
+License: TO_BE_FILLED_IN
+Source0: %{name}-%{version}.tar.gz
+BuildRequires: cmake
+BuildRequires: swig
+#BuildRequires: ruby
+#BuildRequires: ruby-devel
+
+#BuildRequires: mono-core
+#BuildRequires: mono-compat
+#BuildRequires: mono-data
+BuildRequires: mono-compiler
+#BuildRequires: mono-wcf
+#BuildRequires: mono-web
+
+BuildRequires: pkgconfig
+
+BuildRequires: pkgconfig(glib-2.0)
+BuildRequires: pkgconfig(dali-core)
+BuildRequires: pkgconfig(dali-adaptor)
+BuildRequires: pkgconfig(dali-toolkit)
+
+BuildRequires: dali-devel
+BuildRequires: dali-integration-devel
+BuildRequires: dali-adaptor-devel
+BuildRequires: dali-adaptor-integration-devel
+BuildRequires: dali-toolkit-devel
+
+
+%description
+dali wrapper
+
+%package dali-wrapper
+
+Summary: Development dali-wrapper
+Group: Development/Libraries/Other
+Requires: %{name} = %{version}
+
+%description dali-wrapper
+Development .so for dali wrapper
+%define daliSwigDir %{_builddir}/%{name}-%{version}/build/tizen
+%define daliToolkitDir %{_builddir}/dali-toolkit-%{version}/build/tizen
+%define daliPluginsDir %{_builddir}/%{name}-%{version}/build/tizen/plugins/csharp
+
+#############################
+# profile setup
+#############################
+
+
+%define dali_toolkit_profile MOBILE
+
+%define dali_style_folder 720x1280
+# dali_style to be provided by build system as with dali_toolkit_profile or by passing --define 'dali_style 470x800' to the rpm build command
+
+%if "%{?dali_style}"
+ %define dali_style_folder %{dali_style}
+%endif
+
+# Further resource locations profiles can be provided here otherwise MOBILE will be used
+%if "%{tizen_profile_name}" == "mobile"
+ %define dali_toolkit_profile MOBILE
+%endif
+
+%description
+The OpenGLES Canvas Core Library Toolkit - a set of controls that provide
+user interface functionality.
+
+##############################
+# Preparation
+##############################
+%prep
+%setup -q
+
+#Use TZ_PATH when tizen version is 3.x
+
+%if "%{tizen_version_major}" == "2"
+%define ndali_data_rw_dir /opt/usr/share/dali/
+%define ndali_data_ro_dir /usr/share/dali/
+%else
+%define ndali_data_rw_dir %TZ_SYS_SHARE/dali/
+%define ndali_data_ro_dir %TZ_SYS_RO_SHARE/dali/
+%endif
+##############################
+# Build
+##############################
+%build
+echo "----------------" %{_builddir}
+echo "----------------" %{daliSwigDir}
+echo "----------------" %{_libdir}
+echo "----------------" %{daliPluginsDir}
+
+PREFIX="/usr"
+CXXFLAGS+=" -Wall -g -Os -fPIC -fvisibility-inlines-hidden -fdata-sections -ffunction-sections "
+LDFLAGS+=" -Wl,--rpath=$PREFIX/lib -Wl,--as-needed -Wl,--gc-sections -Wl,-Bsymbolic-functions "
+
+%if 0%{?enable_coverage}
+CXXFLAGS+=" --coverage "
+LDFLAGS+=" --coverage "
+%endif
+
+
+##############################
+# Build dali-wrap
+##############################
+
+libtoolize --force
+cd %{daliSwigDir}
+autoreconf --install
+NDALI_DATA_RW_DIR="%{ndali_data_rw_dir}" ; export NDALI_DATA_RW_DIR
+NDALI_DATA_RO_DIR="%{ndali_data_ro_dir}" ; export NDALI_DATA_RO_DIR
+%configure --enable-profile=%{dali_toolkit_profile} \
+ --with-style=%{dali_style_folder} \
+ --enable-csharp=yes \
+%if 0%{?enable_debug}
+ --enable-debug \
+%endif
+ --enable-i18n=yes
+cd %{daliPluginsDir}
+make gbs-local
+
+##############################
+# Installation
+##############################
+echo "----------------" %{_buildrootdir}
+%install
+cd "%{daliPluginsDir}"
+make DESTDIR=%{_buildrootdir}/%{name}-%{version}-%{release}.arm/usr/lib/ gbs-install
+
+#mv %{_builddir}/%{name}-%{version}/plugins/dali-swig/NDali.dll %{_buildrootdir}/%{name}-%{version}-%{release}.arm/usr/lib/
+
+##############################
+# Post Install
+##############################
+%post
+
+
+##############################
+# Files in Binary Packages
+##############################
+%files
+%manifest dali-csharp-wrapper.manifest
+%defattr(-,root,root,-)
+%{_libdir}/lib*
+%{_libdir}/NDali.dll
+%{_libdir}/*.exe
+
#include <dali/public-api/adaptor-framework/window.h>
#include <dali/public-api/adaptor-framework/style-change.h>
#include <dali/devel-api/adaptor-framework/drag-and-drop-detector.h>
+#include <dali/devel-api/adaptor-framework/application-extensions.h>
#include <dali/devel-api/images/nine-patch-image.h>
#include <dali-toolkit/devel-api/builder/builder.h>
+
+#include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
#include <dali-toolkit/devel-api/controls/popup/popup.h>
#include <dali-toolkit/devel-api/controls/progress-bar/progress-bar.h>
#include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
#include <dali-toolkit/devel-api/visual-factory/visual-base.h>
#include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
+#include <dali-toolkit/devel-api/visual-factory/transition-data.h>
#include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
using namespace Dali;
using namespace Dali::Toolkit;
-SWIGINTERN bool Dali_BaseHandle_IsHandleEmpty(Dali::BaseHandle const *self){
+SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self){
+
+ // C++ code. DALi uses Handle <-> Body design pattern.
+ // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
+ // Handles in DALi can be converted into a boolean type
+ // to check if the handle has a valid body attached to it.
+ // Internally checking *self will checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
if( *self )
{
return true;
return false;
}
}
+SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs){
+
+ // C++ code. Check if two handles reference the same implemtion
+ if( *self == rhs)
+ {
+ return true;
+ }
+ else
+ {
+ return false;
+ }
+ }
SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
std::vector< Dali::TouchPoint >* pv = 0;
if (capacity >= 0) {
}
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
+ void * jresult ;
+ Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
+ Dali::Property::Value *arg2 = 0 ;
+ Dali::Property::Array *result = 0 ;
+
+ arg1 = (Dali::Property::Array *)jarg1;
+ arg2 = (Dali::Property::Value *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*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 = (void *)result;
+ return jresult;
+}
+
+
SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
void * jresult ;
Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
}
-SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsHandleEmpty(void * jarg1) {
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
+ unsigned int jresult ;
+ Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
+ bool result;
+
+ arg1 = (Dali::BaseHandle *)jarg1;
+ {
+ try {
+ result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle 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 int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
unsigned int jresult ;
Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
+ Dali::BaseHandle *arg2 = 0 ;
bool result;
arg1 = (Dali::BaseHandle *)jarg1;
+ arg2 = (Dali::BaseHandle *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
+ return 0;
+ }
{
try {
- result = (bool)Dali_BaseHandle_IsHandleEmpty((Dali::BaseHandle const *)arg1);
+ result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
} catch (std::out_of_range& e) {
{
SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
}
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3) {
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_0() {
void * jresult ;
- Dali::PositionSize arg1 ;
- std::string *arg2 = 0 ;
- bool arg3 ;
- Dali::PositionSize *argp1 ;
- Dali::Window result;
+ Dali::ApplicationExtensions *result = 0 ;
- argp1 = (Dali::PositionSize *)jarg1;
- if (!argp1) {
- SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
- return 0;
- }
- arg1 = *argp1;
- if (!jarg2) {
- SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
- return 0;
+ {
+ try {
+ result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions();
+ } 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;
+ };
+ }
}
- std::string arg2_str(jarg2);
- arg2 = &arg2_str;
- arg3 = jarg3 ? true : false;
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_1(void * jarg1) {
+ void * jresult ;
+ Dali::Application *arg1 = (Dali::Application *) 0 ;
+ Dali::ApplicationExtensions *result = 0 ;
+
+ arg1 = (Dali::Application *)jarg1;
{
try {
- result = Dali::Window::New(arg1,(std::string const &)*arg2,arg3);
+ result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions(arg1);
} catch (std::out_of_range& e) {
{
SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
};
}
}
- jresult = new Dali::Window((const Dali::Window &)result);
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationExtensions(void * jarg1) {
+ Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
- //argout typemap for const std::string&
+ arg1 = (Dali::ApplicationExtensions *)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_Dali_ApplicationExtensions_Init(void * jarg1) {
+ Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
- return jresult;
+ arg1 = (Dali::ApplicationExtensions *)jarg1;
+ {
+ try {
+ (arg1)->Init();
+ } 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_Dali_Window_New__SWIG_1(void * jarg1, char * jarg2) {
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Terminate(void * jarg1) {
+ Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
+
+ arg1 = (Dali::ApplicationExtensions *)jarg1;
+ {
+ try {
+ (arg1)->Terminate();
+ } 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_Dali_ApplicationExtensions_Pause(void * jarg1) {
+ Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
+
+ arg1 = (Dali::ApplicationExtensions *)jarg1;
+ {
+ try {
+ (arg1)->Pause();
+ } 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_Dali_ApplicationExtensions_Resume(void * jarg1) {
+ Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
+
+ arg1 = (Dali::ApplicationExtensions *)jarg1;
+ {
+ try {
+ (arg1)->Resume();
+ } 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_Dali_ApplicationExtensions_LanguageChange(void * jarg1) {
+ Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
+
+ arg1 = (Dali::ApplicationExtensions *)jarg1;
+ {
+ try {
+ (arg1)->LanguageChange();
+ } 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_Dali_Window_New__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3) {
void * jresult ;
Dali::PositionSize arg1 ;
std::string *arg2 = 0 ;
+ bool arg3 ;
Dali::PositionSize *argp1 ;
Dali::Window result;
}
std::string arg2_str(jarg2);
arg2 = &arg2_str;
+ arg3 = jarg3 ? true : false;
{
try {
- result = Dali::Window::New(arg1,(std::string const &)*arg2);
+ result = Dali::Window::New(arg1,(std::string const &)*arg2,arg3);
} catch (std::out_of_range& e) {
{
SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
}
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_2(void * jarg1, char * jarg2, char * jarg3, unsigned int jarg4) {
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_1(void * jarg1, char * jarg2) {
void * jresult ;
Dali::PositionSize arg1 ;
std::string *arg2 = 0 ;
- std::string *arg3 = 0 ;
- bool arg4 ;
Dali::PositionSize *argp1 ;
Dali::Window result;
}
std::string arg2_str(jarg2);
arg2 = &arg2_str;
- if (!jarg3) {
- SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
- return 0;
- }
- std::string arg3_str(jarg3);
- arg3 = &arg3_str;
- arg4 = jarg4 ? true : false;
{
try {
- result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*arg3,arg4);
+ result = Dali::Window::New(arg1,(std::string const &)*arg2);
} catch (std::out_of_range& e) {
{
SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
//argout typemap for const std::string&
-
- //argout typemap for const std::string&
-
return jresult;
}
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_3(void * jarg1, char * jarg2, char * jarg3) {
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_2(void * jarg1, char * jarg2, char * jarg3, unsigned int jarg4) {
+ void * jresult ;
+ Dali::PositionSize arg1 ;
+ std::string *arg2 = 0 ;
+ std::string *arg3 = 0 ;
+ bool arg4 ;
+ Dali::PositionSize *argp1 ;
+ Dali::Window result;
+
+ argp1 = (Dali::PositionSize *)jarg1;
+ if (!argp1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
+ return 0;
+ }
+ arg1 = *argp1;
+ if (!jarg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
+ return 0;
+ }
+ std::string arg2_str(jarg2);
+ arg2 = &arg2_str;
+ if (!jarg3) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
+ return 0;
+ }
+ std::string arg3_str(jarg3);
+ arg3 = &arg3_str;
+ arg4 = jarg4 ? true : false;
+ {
+ try {
+ result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*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::Window((const Dali::Window &)result);
+
+ //argout typemap for const std::string&
+
+
+ //argout typemap for const std::string&
+
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_3(void * jarg1, char * jarg2, char * jarg3) {
void * jresult ;
Dali::PositionSize arg1 ;
std::string *arg2 = 0 ;
}
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BATCHING_ENABLED_get() {
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCHING_ENABLED_get() {
int jresult ;
int result;
}
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PIXEL_AREA_get() {
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
int jresult ;
int result;
}
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WRAP_MODE_U_get() {
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
int jresult ;
int result;
}
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WRAP_MODE_V_get() {
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
+ int jresult ;
+ int result;
+
+ {
+ try {
+ result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
+ } 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 = (int)result;
+ return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_OBJECT_URL_get() {
+ int jresult ;
+ int result;
+
+ {
+ try {
+ result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
+ } 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 = (int)result;
+ return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MATERIAL_URL_get() {
+ int jresult ;
+ int result;
+
+ {
+ try {
+ result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
+ } 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 = (int)result;
+ return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXTURES_PATH_get() {
+ int jresult ;
+ int result;
+
+ {
+ try {
+ result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
+ } 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 = (int)result;
+ return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_SHADING_MODE_get() {
+ int jresult ;
+ int result;
+
+ {
+ try {
+ result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
+ } 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 = (int)result;
+ return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_USE_MIPMAPPING_get() {
+ int jresult ;
+ int result;
+
+ {
+ try {
+ result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
+ } 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 = (int)result;
+ return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_USE_SOFT_NORMALS_get() {
+ int jresult ;
+ int result;
+
+ {
+ try {
+ result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
+ } 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 = (int)result;
+ return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LIGHT_POSITION_get() {
+ int jresult ;
+ int result;
+
+ {
+ try {
+ result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
+ } 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 = (int)result;
+ return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_SHAPE_get() {
+ int jresult ;
+ int result;
+
+ {
+ try {
+ result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
+ } 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 = (int)result;
+ return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
+ int jresult ;
+ int result;
+
+ {
+ try {
+ result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
+ } 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 = (int)result;
+ return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_SLICES_get() {
+ int jresult ;
+ int result;
+
+ {
+ try {
+ result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
+ } 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 = (int)result;
+ return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_STACKS_get() {
+ int jresult ;
+ int result;
+
+ {
+ try {
+ result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
+ } 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 = (int)result;
+ return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_SCALE_TOP_RADIUS_get() {
+ int jresult ;
+ int result;
+
+ {
+ try {
+ result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
+ } 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 = (int)result;
+ return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_SCALE_BOTTOM_RADIUS_get() {
+ int jresult ;
+ int result;
+
+ {
+ try {
+ result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
+ } 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 = (int)result;
+ return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_SCALE_HEIGHT_get() {
+ int jresult ;
+ int result;
+
+ {
+ try {
+ result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
+ } 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 = (int)result;
+ return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_SCALE_RADIUS_get() {
+ int jresult ;
+ int result;
+
+ {
+ try {
+ result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
+ } 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 = (int)result;
+ return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_SCALE_DIMENSIONS_get() {
+ int jresult ;
+ int result;
+
+ {
+ try {
+ result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
+ } 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 = (int)result;
+ return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BEVEL_PERCENTAGE_get() {
+ int jresult ;
+ int result;
+
+ {
+ try {
+ result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
+ } 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 = (int)result;
+ return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BEVEL_SMOOTHNESS_get() {
+ int jresult ;
+ int result;
+
+ {
+ try {
+ result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
+ } 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 = (int)result;
+ return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
+ int jresult ;
+ int result;
+
+ {
+ try {
+ result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
+ } 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 = (int)result;
+ return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RENDERING_BACKEND_get() {
int jresult ;
int result;
{
try {
- result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
+ result = (int)Dali::Toolkit::TextVisual::Property::RENDERING_BACKEND;
} catch (std::out_of_range& e) {
{
SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
}
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_OBJECT_URL_get() {
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_get() {
int jresult ;
int result;
{
try {
- result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
+ result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
} catch (std::out_of_range& e) {
{
SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
}
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MATERIAL_URL_get() {
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FONT_FAMILY_get() {
int jresult ;
int result;
{
try {
- result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
+ result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
} catch (std::out_of_range& e) {
{
SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
}
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXTURES_PATH_get() {
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FONT_STYLE_get() {
int jresult ;
int result;
{
try {
- result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
+ result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
} catch (std::out_of_range& e) {
{
SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
}
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_SHADING_MODE_get() {
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_POINT_SIZE_get() {
int jresult ;
int result;
{
try {
- result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
+ result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
} catch (std::out_of_range& e) {
{
SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
}
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_USE_MIPMAPPING_get() {
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MULTI_LINE_get() {
int jresult ;
int result;
{
try {
- result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
+ result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
} catch (std::out_of_range& e) {
{
SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
}
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_USE_SOFT_NORMALS_get() {
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_HORIZONTAL_ALIGNMENT_get() {
int jresult ;
int result;
{
try {
- result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
+ result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
} catch (std::out_of_range& e) {
{
SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
}
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LIGHT_POSITION_get() {
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VERTICAL_ALIGNMENT_get() {
int jresult ;
int result;
{
try {
- result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
+ result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
} catch (std::out_of_range& e) {
{
SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
}
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_SHAPE_get() {
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_COLOR_get() {
int jresult ;
int result;
{
try {
- result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
+ result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
} catch (std::out_of_range& e) {
{
SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
}
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ENABLE_MARKUP_get() {
int jresult ;
int result;
{
try {
- result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
+ result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
} catch (std::out_of_range& e) {
{
SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
}
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_SLICES_get() {
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ENABLE_AUTO_SCROLL_get() {
int jresult ;
int result;
{
try {
- result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
+ result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_AUTO_SCROLL;
} catch (std::out_of_range& e) {
{
SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
}
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_STACKS_get() {
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AUTO_SCROLL_SPEED_get() {
int jresult ;
int result;
{
try {
- result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
+ result = (int)Dali::Toolkit::TextVisual::Property::AUTO_SCROLL_SPEED;
} catch (std::out_of_range& e) {
{
SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
}
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_SCALE_TOP_RADIUS_get() {
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AUTO_SCROLL_LOOP_COUNT_get() {
int jresult ;
int result;
{
try {
- result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
+ result = (int)Dali::Toolkit::TextVisual::Property::AUTO_SCROLL_LOOP_COUNT;
} catch (std::out_of_range& e) {
{
SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
}
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_SCALE_BOTTOM_RADIUS_get() {
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AUTO_SCROLL_GAP_get() {
int jresult ;
int result;
{
try {
- result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
+ result = (int)Dali::Toolkit::TextVisual::Property::AUTO_SCROLL_GAP;
} catch (std::out_of_range& e) {
{
SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
}
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_SCALE_HEIGHT_get() {
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LINE_SPACING_get() {
int jresult ;
int result;
{
try {
- result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
+ result = (int)Dali::Toolkit::TextVisual::Property::LINE_SPACING;
} catch (std::out_of_range& e) {
{
SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
}
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_SCALE_RADIUS_get() {
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_UNDERLINE_get() {
int jresult ;
int result;
{
try {
- result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
+ result = (int)Dali::Toolkit::TextVisual::Property::UNDERLINE;
} catch (std::out_of_range& e) {
{
SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
}
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_SCALE_DIMENSIONS_get() {
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_SHADOW_get() {
int jresult ;
int result;
{
try {
- result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
+ result = (int)Dali::Toolkit::TextVisual::Property::SHADOW;
} catch (std::out_of_range& e) {
{
SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
}
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BEVEL_PERCENTAGE_get() {
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_EMBOSS_get() {
int jresult ;
int result;
{
try {
- result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
+ result = (int)Dali::Toolkit::TextVisual::Property::EMBOSS;
} catch (std::out_of_range& e) {
{
SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
}
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BEVEL_SMOOTHNESS_get() {
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_OUTLINE_get() {
int jresult ;
int result;
{
try {
- result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
+ result = (int)Dali::Toolkit::TextVisual::Property::OUTLINE;
} catch (std::out_of_range& e) {
{
SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
}
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BATCHING_ENABLED_get() {
int jresult ;
int result;
{
try {
- result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
+ result = (int)Dali::Toolkit::TextVisual::Property::BATCHING_ENABLED;
} catch (std::out_of_range& e) {
{
SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
}
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
+ void * jresult ;
+ Dali::Toolkit::TransitionData *result = 0 ;
+
+ {
+ try {
+ result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
+ } 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_Dali_delete_TransitionData(void * jarg1) {
+ Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
+
+ arg1 = (Dali::Toolkit::TransitionData *)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_Dali_TransitionData_New__SWIG_0(void * jarg1) {
+ void * jresult ;
+ Dali::Property::Map *arg1 = 0 ;
+ Dali::Toolkit::TransitionData result;
+
+ arg1 = (Dali::Property::Map *)jarg1;
+ if (!arg1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = Dali::Toolkit::TransitionData::New((Dali::Property::Map 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 = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
+ void * jresult ;
+ Dali::Property::Array *arg1 = 0 ;
+ Dali::Toolkit::TransitionData result;
+
+ arg1 = (Dali::Property::Array *)jarg1;
+ if (!arg1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = Dali::Toolkit::TransitionData::New((Dali::Property::Array 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 = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
+ void * jresult ;
+ Dali::BaseHandle arg1 ;
+ Dali::BaseHandle *argp1 ;
+ Dali::Toolkit::TransitionData result;
+
+ argp1 = (Dali::BaseHandle *)jarg1;
+ if (!argp1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
+ return 0;
+ }
+ arg1 = *argp1;
+ {
+ try {
+ result = Dali::Toolkit::TransitionData::DownCast(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 = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
+ void * jresult ;
+ Dali::Toolkit::TransitionData *arg1 = 0 ;
+ Dali::Toolkit::TransitionData *result = 0 ;
+
+ arg1 = (Dali::Toolkit::TransitionData *)jarg1;
+ if (!arg1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData 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 = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
+ void * jresult ;
+ Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
+ Dali::Toolkit::TransitionData *arg2 = 0 ;
+ Dali::Toolkit::TransitionData *result = 0 ;
+
+ arg1 = (Dali::Toolkit::TransitionData *)jarg1;
+ arg2 = (Dali::Toolkit::TransitionData *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*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 = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
+ unsigned long jresult ;
+ Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
+ size_t result;
+
+ arg1 = (Dali::Toolkit::TransitionData *)jarg1;
+ {
+ try {
+ result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
+ } 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;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
+ void * jresult ;
+ Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
+ size_t arg2 ;
+ Dali::Property::Map result;
+
+ arg1 = (Dali::Toolkit::TransitionData *)jarg1;
+ arg2 = (size_t)jarg2;
+ {
+ try {
+ result = (arg1)->GetAnimatorAt(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::Property::Map((const Dali::Property::Map &)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_2(void * jarg1) {
+ void * jresult ;
+ Dali::Toolkit::Internal::TransitionData *arg1 = (Dali::Toolkit::Internal::TransitionData *) 0 ;
+ Dali::Toolkit::TransitionData *result = 0 ;
+
+ arg1 = (Dali::Toolkit::Internal::TransitionData *)jarg1;
+ {
+ try {
+ result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData(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 = (void *)result;
+ return jresult;
+}
+
+
SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
void * jresult ;
Dali::Toolkit::Control result;
}
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
+ void * jresult ;
+ Dali::Toolkit::KeyInputFocusManager *result = 0 ;
+
+ {
+ try {
+ result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
+ } 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_Dali_delete_KeyInputFocusManager(void * jarg1) {
+ Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
+
+ arg1 = (Dali::Toolkit::KeyInputFocusManager *)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_Dali_KeyInputFocusManager_Get() {
+ void * jresult ;
+ Dali::Toolkit::KeyInputFocusManager result;
+
+ {
+ try {
+ result = Dali::Toolkit::KeyInputFocusManager::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::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
+ Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
+ Dali::Toolkit::Control arg2 ;
+ Dali::Toolkit::Control *argp2 ;
+
+ arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
+ argp2 = (Dali::Toolkit::Control *)jarg2;
+ if (!argp2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
+ return ;
+ }
+ arg2 = *argp2;
+ {
+ try {
+ (arg1)->SetFocus(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_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
+ void * jresult ;
+ Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
+ Dali::Toolkit::Control result;
+
+ arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
+ {
+ try {
+ result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
+ } 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::Control((const Dali::Toolkit::Control &)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
+ Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
+ Dali::Toolkit::Control arg2 ;
+ Dali::Toolkit::Control *argp2 ;
+
+ arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
+ argp2 = (Dali::Toolkit::Control *)jarg2;
+ if (!argp2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
+ return ;
+ }
+ arg2 = *argp2;
+ {
+ try {
+ (arg1)->RemoveFocus(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_Dali_KeyInputFocusManager_IsKeyboardListener(void * jarg1, void * jarg2) {
+ unsigned int jresult ;
+ Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
+ Dali::Toolkit::Control arg2 ;
+ Dali::Toolkit::Control *argp2 ;
+ bool result;
+
+ arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
+ argp2 = (Dali::Toolkit::Control *)jarg2;
+ if (!argp2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
+ return 0;
+ }
+ arg2 = *argp2;
+ {
+ try {
+ result = (bool)(arg1)->IsKeyboardListener(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_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
+ void * jresult ;
+ Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
+ Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
+
+ arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
+ {
+ try {
+ result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
+ } 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_Dali_KeyInputFocusManager_UnhandledKeyEventSignal(void * jarg1) {
+ void * jresult ;
+ Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
+ Dali::Toolkit::KeyInputFocusManager::UnhandledKeyEventSignalType *result = 0 ;
+
+ arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
+ {
+ try {
+ result = (Dali::Toolkit::KeyInputFocusManager::UnhandledKeyEventSignalType *) &(arg1)->UnhandledKeyEventSignal();
+ } 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_Dali_new_Alignment_Padding__SWIG_0() {
void * jresult ;
Dali::Toolkit::Alignment::Padding *result = 0 ;
void * jresult ;
Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
unsigned int arg2 ;
- Dali::Image result;
+ Dali::Texture result;
arg1 = (Dali::Toolkit::PageFactory *)jarg1;
arg2 = (unsigned int)jarg2;
};
}
}
- jresult = new Dali::Image((const Dali::Image &)result);
+ jresult = new Dali::Texture((const Dali::Texture &)result);
return jresult;
}
}
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetSize(void * jarg1, void * jarg2) {
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
- Dali::Vector2 *arg2 = 0 ;
+ std::string *arg2 = 0 ;
arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
- arg2 = (Dali::Vector2 *)jarg2;
- if (!arg2) {
- SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
+ if (!jarg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
return ;
- }
+ }
+ std::string arg2_str(jarg2);
+ arg2 = &arg2_str;
{
try {
- (arg1)->SetSize((Dali::Vector2 const &)*arg2);
+ (arg1)->SetName((std::string const &)*arg2);
} catch (std::out_of_range& e) {
{
SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
};
}
}
+
+ //argout typemap for const std::string&
+
}
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_GetSize(void * jarg1) {
- void * jresult ;
+SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
+ char * jresult ;
Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
- Dali::Vector2 *result = 0 ;
+ std::string *result = 0 ;
arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
{
try {
- result = (Dali::Vector2 *) &((Dali::Toolkit::Visual::Base const *)arg1)->GetSize();
+ result = (std::string *) &(arg1)->GetName();
} catch (std::out_of_range& e) {
{
SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
};
}
}
- jresult = (void *)result;
+ jresult = SWIG_csharp_string_callback(result->c_str());
return jresult;
}
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetSize(void * jarg1, void * jarg2) {
Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
Dali::Vector2 *arg2 = 0 ;
arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
arg2 = (Dali::Vector2 *)jarg2;
if (!arg2) {
- SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
return ;
}
{
try {
- ((Dali::Toolkit::Visual::Base const *)arg1)->GetNaturalSize(*arg2);
+ (arg1)->SetSize((Dali::Vector2 const &)*arg2);
} catch (std::out_of_range& e) {
{
SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
}
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, float jarg2) {
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_GetSize(void * jarg1) {
+ void * jresult ;
Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
- float arg2 ;
+ Dali::Vector2 *result = 0 ;
arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
- arg2 = (float)jarg2;
{
try {
- (arg1)->SetDepthIndex(arg2);
+ result = (Dali::Vector2 *) &((Dali::Toolkit::Visual::Base const *)arg1)->GetSize();
} catch (std::out_of_range& e) {
{
- SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
+ 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 ;
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
};
} catch (...) {
{
- SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
};
}
}
+ jresult = (void *)result;
+ return jresult;
}
-SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
float jresult ;
Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
+ float arg2 ;
float result;
arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
+ arg2 = (float)jarg2;
{
try {
- result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
+ result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetHeightForWidth(arg2);
} catch (std::out_of_range& e) {
{
SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
}
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetOnStage(void * jarg1, void * jarg2) {
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
- Dali::Actor *arg2 = 0 ;
+ Dali::Vector2 *arg2 = 0 ;
arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
- arg2 = (Dali::Actor *)jarg2;
+ arg2 = (Dali::Vector2 *)jarg2;
if (!arg2) {
- SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
return ;
}
{
try {
- (arg1)->SetOnStage(*arg2);
+ (arg1)->GetNaturalSize(*arg2);
} catch (std::out_of_range& e) {
{
SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
}
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetOffStage(void * jarg1, void * jarg2) {
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, float jarg2) {
Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
- Dali::Actor *arg2 = 0 ;
+ float arg2 ;
arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
- arg2 = (Dali::Actor *)jarg2;
- if (!arg2) {
- SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
- return ;
- }
+ arg2 = (float)jarg2;
{
try {
- (arg1)->SetOffStage(*arg2);
+ (arg1)->SetDepthIndex(arg2);
} catch (std::out_of_range& e) {
{
SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
}
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_RemoveAndReset(void * jarg1, void * jarg2) {
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
+ float jresult ;
Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
- Dali::Actor *arg2 = 0 ;
+ float result;
arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
- arg2 = (Dali::Actor *)jarg2;
- if (!arg2) {
- SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
- return ;
- }
{
try {
- (arg1)->RemoveAndReset(*arg2);
+ result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
} catch (std::out_of_range& e) {
{
- SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
+ 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 ;
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
};
} catch (...) {
{
- SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
};
}
}
+ jresult = result;
+ return jresult;
}
}
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetProperty(void * jarg1, int jarg2, void * jarg3) {
+ Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
+ Dali::Property::Index arg2 ;
+ Dali::Property::Value *arg3 = 0 ;
+
+ arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
+ arg2 = (Dali::Property::Index)jarg2;
+ arg3 = (Dali::Property::Value *)jarg3;
+ if (!arg3) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
+ return ;
+ }
+ {
+ try {
+ (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*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 void * SWIGSTDCALL CSharp_Dali_VisualBase_GetProperty(void * jarg1, int jarg2) {
+ void * jresult ;
+ Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
+ Dali::Property::Index arg2 ;
+ Dali::Property::Value result;
+
+ arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
+ arg2 = (Dali::Property::Index)jarg2;
+ {
+ try {
+ result = (arg1)->GetProperty(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::Property::Value((const Dali::Property::Value &)result);
+ return jresult;
+}
+
+
SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_2(void * jarg1) {
void * jresult ;
Dali::Toolkit::Internal::Visual::Base *arg1 = (Dali::Toolkit::Internal::Visual::Base *) 0 ;
return (Dali::BaseHandle *)jarg1;
}
+SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
+ return (Dali::BaseHandle *)jarg1;
+}
+
SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
return (Dali::CustomActorImpl *)jarg1;
}
return (Dali::CustomActor *)jarg1;
}
+SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
+ return (Dali::BaseHandle *)jarg1;
+}
+
SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
return (Dali::Toolkit::Control *)jarg1;
}
if (_accessibilityManagerStatusChangedEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerStatusChangedEventHandler(this, e, true);
+ return _accessibilityManagerStatusChangedEventHandler(this, e);
}
return false;
}
if (_accessibilityManagerActionNextEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionNextEventHandler(this, e, true);
+ return _accessibilityManagerActionNextEventHandler(this, e);
}
return false;
}
if (_accessibilityManagerActionPreviousEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionPreviousEventHandler(this, e, true);
+ return _accessibilityManagerActionPreviousEventHandler(this, e);
}
return false;
}
if (_accessibilityManagerActionActivateEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionActivateEventHandler(this, e, true);
+ return _accessibilityManagerActionActivateEventHandler(this, e);
}
return false;
}
if (_accessibilityManagerActionReadEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionReadEventHandler(this, e, true);
+ return _accessibilityManagerActionReadEventHandler(this, e);
}
return false;
}
if (_accessibilityManagerActionOverEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionOverEventHandler(this, e, true);
+ return _accessibilityManagerActionOverEventHandler(this, e);
}
return false;
}
if (_accessibilityManagerActionReadNextEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionReadNextEventHandler(this, e, true);
+ return _accessibilityManagerActionReadNextEventHandler(this, e);
}
return false;
}
if (_accessibilityManagerActionReadPreviousEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionReadPreviousEventHandler(this, e, true);
+ return _accessibilityManagerActionReadPreviousEventHandler(this, e);
}
return false;
}
if (_accessibilityManagerActionUpEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionUpEventHandler(this, e, true);
+ return _accessibilityManagerActionUpEventHandler(this, e);
}
return false;
}
if (_accessibilityManagerActionDownEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionDownEventHandler(this, e, true);
+ return _accessibilityManagerActionDownEventHandler(this, e);
}
return false;
}
if (_accessibilityManagerActionClearFocusEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionClearFocusEventHandler(this, e, true);
+ return _accessibilityManagerActionClearFocusEventHandler(this, e);
}
return false;
}
if (_accessibilityManagerActionBackEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionBackEventHandler(this, e, true);
+ return _accessibilityManagerActionBackEventHandler(this, e);
}
return false;
}
if (_accessibilityManagerActionScrollUpEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionScrollUpEventHandler(this, e, true);
+ return _accessibilityManagerActionScrollUpEventHandler(this, e);
}
return false;
}
if (_accessibilityManagerActionScrollDownEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionScrollDownEventHandler(this, e, true);
+ return _accessibilityManagerActionScrollDownEventHandler(this, e);
}
return false;
}
if (_accessibilityManagerActionPageLeftEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionPageLeftEventHandler(this, e, true);
+ return _accessibilityManagerActionPageLeftEventHandler(this, e);
}
return false;
}
if (_accessibilityManagerActionPageRightEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionPageRightEventHandler(this, e, true);
+ return _accessibilityManagerActionPageRightEventHandler(this, e);
}
return false;
}
if (_accessibilityManagerActionPageUpEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionPageUpEventHandler(this, e, true);
+ return _accessibilityManagerActionPageUpEventHandler(this, e);
}
return false;
}
if (_accessibilityManagerActionPageDownEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionPageDownEventHandler(this, e, true);
+ return _accessibilityManagerActionPageDownEventHandler(this, e);
}
return false;
}
if (_accessibilityManagerActionMoveToFirstEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionMoveToFirstEventHandler(this, e, true);
+ return _accessibilityManagerActionMoveToFirstEventHandler(this, e);
}
return false;
}
if (_accessibilityManagerActionMoveToLastEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionMoveToLastEventHandler(this, e, true);
+ return _accessibilityManagerActionMoveToLastEventHandler(this, e);
}
return false;
}
if (_accessibilityManagerActionReadFromTopEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionReadFromTopEventHandler(this, e, true);
+ return _accessibilityManagerActionReadFromTopEventHandler(this, e);
}
return false;
}
if (_accessibilityManagerActionReadFromNextEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionReadFromNextEventHandler(this, e, true);
+ return _accessibilityManagerActionReadFromNextEventHandler(this, e);
}
return false;
}
if (_accessibilityManagerActionZoomEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionZoomEventHandler(this, e, true);
+ return _accessibilityManagerActionZoomEventHandler(this, e);
}
return false;
}
if (_accessibilityManagerActionReadIndicatorInformationEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionReadIndicatorInformationEventHandler(this, e, true);
+ return _accessibilityManagerActionReadIndicatorInformationEventHandler(this, e);
}
return false;
}
if (_accessibilityManagerActionReadPauseResumeEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionReadPauseResumeEventHandler(this, e, true);
+ return _accessibilityManagerActionReadPauseResumeEventHandler(this, e);
}
return false;
}
if (_accessibilityManagerActionStartStopEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionStartStopEventHandler(this, e, true);
+ return _accessibilityManagerActionStartStopEventHandler(this, e);
}
return false;
}
if (_accessibilityManagerActionScrollEventHandler != null)
{
//here we send all data to user event handlers
- return _accessibilityManagerActionScrollEventHandler(this, e, true);
+ return _accessibilityManagerActionScrollEventHandler(this, e);
}
return false;
}
}
-
- /**
- * @brief Event arguments that passed via Touch signal
- *
- */
- public class TouchEventArgs : EventArgs
- {
- private Actor _actor;
- private TouchData _touchData;
-
- /**
- * @brief Actor - is the actor that is being touched
- *
- */
- public Actor Actor
- {
- get
- {
- return _actor;
- }
- set
- {
- _actor = value;
- }
- }
-
- /**
- * @brief TouchData - contains the information of touch points
- *
- */
- public TouchData TouchData
- {
- get
- {
- return _touchData;
- }
- set
- {
- _touchData = value;
- }
- }
- }
-
- /**
- * @brief Event arguments that passed via Hover signal
- *
- */
- public class HoverEventArgs : EventArgs
- {
- private Actor _actor;
- private HoverEvent _hoverEvent;
-
- /**
- * @brief Actor - is the actor that is being hovered
- *
- */
- public Actor Actor
- {
- get
- {
- return _actor;
- }
- set
- {
- _actor = value;
- }
- }
-
- /**
- * @brief HoverEvent - contains touch points that represent the points
- * that are currently being hovered or the points where a hover has stopped
- *
- */
- public HoverEvent HoverEvent
- {
- get
- {
- return _hoverEvent;
- }
- set
- {
- _hoverEvent = value;
- }
- }
- }
-
- /**
- * @brief Event arguments that passed via Wheel signal
- *
- */
- public class WheelEventArgs : EventArgs
- {
- private Actor _actor;
- private WheelEvent _wheelEvent;
-
- /**
- * @brief Actor - is the actor that is being wheeled
- *
- */
- public Actor Actor
- {
- get
- {
- return _actor;
- }
- set
- {
- _actor = value;
- }
- }
-
- /**
- * @brief WheelEvent - store a wheel rolling type : MOUSE_WHEEL or CUSTOM_WHEEL
- *
- */
- public WheelEvent WheelEvent
- {
- get
- {
- return _wheelEvent;
- }
- set
- {
- _wheelEvent = value;
- }
- }
- }
-
- /**
- * @brief Event arguments that passed via OnStage signal
- *
- */
- public class OnStageEventArgs : EventArgs
- {
- private Actor _actor;
-
- /**
- * @brief Actor - is the actor that is being connected to the stage
- *
- */
- public Actor Actor
- {
- get
- {
- return _actor;
- }
- set
- {
- _actor = value;
- }
- }
- }
-
- /**
- * @brief Event arguments that passed via OffStage signal
- *
- */
- public class OffStageEventArgs : EventArgs
- {
- private Actor _actor;
-
- /**
- * @brief Actor - is the actor that is being disconnected from the stage
- *
- */
- public Actor Actor
- {
- get
- {
- return _actor;
- }
- set
- {
- _actor = value;
- }
- }
- }
-
- /**
- * @brief Event arguments that passed via OnRelayout signal
- *
- */
- public class OnRelayoutEventArgs : EventArgs
- {
- private Actor _actor;
-
- /**
- * @brief Actor - is the actor that is being resized upon relayout
- *
- */
- public Actor Actor
- {
- get
- {
- return _actor;
- }
- set
- {
- _actor = value;
- }
- }
- }
-
-
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
- private delegate bool TouchCallbackDelegate(IntPtr actor, IntPtr touchData);
- private DaliEventHandlerWithReturnType<object,TouchEventArgs,bool> _actorTouchDataEventHandler;
- private TouchCallbackDelegate _actorTouchDataCallbackDelegate;
-
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
- private delegate bool HoverEventCallbackDelegate(IntPtr actor, IntPtr hoverEvent);
- private DaliEventHandlerWithReturnType<object,HoverEventArgs,bool> _actorHoverEventHandler;
- private HoverEventCallbackDelegate _actorHoverEventCallbackDelegate;
-
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
- private delegate bool WheelEventCallbackDelegate(IntPtr actor, IntPtr wheelEvent);
- private DaliEventHandlerWithReturnType<object,WheelEventArgs,bool> _actorWheelEventHandler;
- private WheelEventCallbackDelegate _actorWheelEventCallbackDelegate;
-
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
- private delegate void OnStageEventCallbackDelegate(IntPtr actor);
- private DaliEventHandler<object,OnStageEventArgs> _actorOnStageEventHandler;
- private OnStageEventCallbackDelegate _actorOnStageEventCallbackDelegate;
-
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
- private delegate void OffStageEventCallbackDelegate(IntPtr actor);
- private DaliEventHandler<object,OffStageEventArgs> _actorOffStageEventHandler;
- private OffStageEventCallbackDelegate _actorOffStageEventCallbackDelegate;
-
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
- private delegate void OnRelayoutEventCallbackDelegate(IntPtr actor);
- 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-DaliEventHandlerWithReturnType<object,TouchEventArgs,bool>)
- * provided by the user. Touched signal is emitted when touch input is received.
- */
- public event DaliEventHandlerWithReturnType<object,TouchEventArgs,bool> Touched
- {
- add
- {
- lock(this)
- {
- // Restricted to only one listener
- if (_actorTouchDataEventHandler == null)
- {
- _actorTouchDataEventHandler += value;
-
- _actorTouchDataCallbackDelegate = new TouchCallbackDelegate(OnTouch);
- this.TouchSignal().Connect(_actorTouchDataCallbackDelegate);
- }
- }
- }
-
- remove
- {
- lock(this)
- {
- if (_actorTouchDataEventHandler != null)
- {
- this.TouchSignal().Disconnect(_actorTouchDataCallbackDelegate);
- }
-
- _actorTouchDataEventHandler -= value;
- }
- }
- }
-
- // Callback for Actor TouchSignal
- private bool OnTouch(IntPtr actor, IntPtr touchData)
- {
- TouchEventArgs e = new TouchEventArgs();
-
- // Populate all members of "e" (TouchEventArgs) with real data
- e.Actor = Actor.GetActorFromPtr(actor);
- e.TouchData = Dali.TouchData.GetTouchDataFromPtr(touchData);
-
- if (_actorTouchDataEventHandler != null)
- {
- //here we send all data to user event handlers
- return _actorTouchDataEventHandler(this, e, true);
- }
-
- return false;
- }
-
- /**
- * @brief Event for Hovered signal which can be used to subscribe/unsubscribe the event handler
- * (in the type of HoverEventHandler-DaliEventHandlerWithReturnType<object,HoverEventArgs,bool>)
- * provided by the user. Hovered signal is emitted when hover input is received.
- */
- public event DaliEventHandlerWithReturnType<object,HoverEventArgs,bool> Hovered
- {
- add
- {
- lock(this)
- {
- // Restricted to only one listener
- if (_actorHoverEventHandler == null)
- {
- _actorHoverEventHandler += value;
-
- _actorHoverEventCallbackDelegate = new HoverEventCallbackDelegate(OnHoverEvent);
- this.HoveredSignal().Connect(_actorHoverEventCallbackDelegate);
- }
- }
- }
-
- remove
- {
- lock(this)
- {
- if (_actorHoverEventHandler != null)
- {
- this.HoveredSignal().Disconnect(_actorHoverEventCallbackDelegate);
- }
-
- _actorHoverEventHandler -= value;
- }
- }
- }
-
- // Callback for Actor Hover signal
- private bool OnHoverEvent(IntPtr actor, IntPtr hoverEvent)
- {
- HoverEventArgs e = new HoverEventArgs();
-
- // Populate all members of "e" (HoverEventArgs) with real data
- e.Actor = Actor.GetActorFromPtr(actor);
- e.HoverEvent = Dali.HoverEvent.GetHoverEventFromPtr(hoverEvent);
-
- if (_actorHoverEventHandler != null)
- {
- //here we send all data to user event handlers
- return _actorHoverEventHandler(this, e, true);
- }
-
- return false;
- }
-
- /**
- * @brief Event for WheelMoved signal which can be used to subscribe/unsubscribe the event handler
- * (in the type of WheelEventHandler-DaliEventHandlerWithReturnType<object,WheelEventArgs,bool>)
- * provided by the user. WheelMoved signal is emitted when wheel event is received.
- */
- public event DaliEventHandlerWithReturnType<object,WheelEventArgs,bool> WheelMoved
- {
- add
- {
- lock(this)
- {
- // Restricted to only one listener
- if (_actorWheelEventHandler == null)
- {
- _actorWheelEventHandler += value;
-
- _actorWheelEventCallbackDelegate = new WheelEventCallbackDelegate(OnWheelEvent);
- this.WheelEventSignal().Connect(_actorWheelEventCallbackDelegate);
- }
- }
- }
-
- remove
- {
- lock(this)
- {
- if (_actorWheelEventHandler != null)
- {
- this.WheelEventSignal().Disconnect(_actorWheelEventCallbackDelegate);
- }
-
- _actorWheelEventHandler -= value;
- }
- }
- }
-
- // Callback for Actor Wheel signal
- private bool OnWheelEvent(IntPtr actor, IntPtr wheelEvent)
- {
- WheelEventArgs e = new WheelEventArgs();
-
- // Populate all members of "e" (WheelEventArgs) with real data
- e.Actor = Actor.GetActorFromPtr(actor);
- e.WheelEvent = Dali.WheelEvent.GetWheelEventFromPtr(wheelEvent);
-
- if (_actorWheelEventHandler != null)
- {
- //here we send all data to user event handlers
- return _actorWheelEventHandler(this, e, true);
- }
-
- return false;
- }
-
- /**
- * @brief Event for OnStage signal which can be used to subscribe/unsubscribe the event handler
- * (in the type of OnStageEventHandler) provided by the user.
- * OnStage signal is emitted after the actor has been connected to the stage.
- */
- public event DaliEventHandler<object,OnStageEventArgs> OnStageEvent
- {
- add
- {
- lock(this)
- {
- // Restricted to only one listener
- if (_actorOnStageEventHandler == null)
- {
- _actorOnStageEventHandler += value;
-
- _actorOnStageEventCallbackDelegate = new OnStageEventCallbackDelegate(OnStage);
- this.OnStageSignal().Connect(_actorOnStageEventCallbackDelegate);
- }
- }
- }
-
- remove
- {
- lock(this)
- {
- if (_actorOnStageEventHandler != null)
- {
- this.OnStageSignal().Disconnect(_actorOnStageEventCallbackDelegate);
- }
-
- _actorOnStageEventHandler -= value;
- }
- }
- }
-
- // Callback for Actor OnStage signal
- private void OnStage(IntPtr data)
- {
- OnStageEventArgs e = new OnStageEventArgs();
-
- // Populate all members of "e" (OnStageEventArgs) with real data
- e.Actor = Actor.GetActorFromPtr(data);
-
- if (_actorOnStageEventHandler != null)
- {
- //here we send all data to user event handlers
- _actorOnStageEventHandler(this, e);
- }
- }
-
- /**
- * @brief Event for OffStage signal which can be used to subscribe/unsubscribe the event handler
- * (in the type of OffStageEventHandler) provided by the user.
- * OffStage signal is emitted after the actor has been disconnected from the stage.
- */
- public event DaliEventHandler<object,OffStageEventArgs> OffStageEvent
- {
- add
- {
- lock(this)
- {
- // Restricted to only one listener
- if (_actorOffStageEventHandler == null)
- {
- _actorOffStageEventHandler += value;
-
- _actorOffStageEventCallbackDelegate = new OffStageEventCallbackDelegate(OffStage);
- this.OnStageSignal().Connect(_actorOffStageEventCallbackDelegate);
- }
- }
- }
-
- remove
- {
- lock(this)
- {
- if (_actorOffStageEventHandler != null)
- {
- this.OnStageSignal().Disconnect(_actorOffStageEventCallbackDelegate);
- }
-
- _actorOffStageEventHandler -= value;
- }
- }
- }
-
- // Callback for Actor OffStage signal
- private void OffStage(IntPtr data)
- {
- OffStageEventArgs e = new OffStageEventArgs();
-
- // Populate all members of "e" (OffStageEventArgs) with real data
- e.Actor = Actor.GetActorFromPtr(data);
-
- if (_actorOffStageEventHandler != null)
- {
- //here we send all data to user event handlers
- _actorOffStageEventHandler(this, e);
- }
- }
-
- /**
- * @brief Event for OnRelayout signal which can be used to subscribe/unsubscribe the event handler
- * (in the type of OnRelayoutEventHandler) provided by the user.
- * OnRelayout signal is emitted after the size has been set on the actor during relayout.
- */
- public event DaliEventHandler<object,OnRelayoutEventArgs> OnRelayoutEvent
- {
- add
- {
- lock(this)
- {
- // Restricted to only one listener
- if (_actorOnRelayoutEventHandler == null)
- {
- _actorOnRelayoutEventHandler += value;
-
- _actorOnRelayoutEventCallbackDelegate = new OnRelayoutEventCallbackDelegate(OnRelayout);
- this.OnRelayoutSignal().Connect(_actorOnRelayoutEventCallbackDelegate);
- }
- }
- }
-
- remove
- {
- lock(this)
- {
- if (_actorOnRelayoutEventHandler != null)
- {
- this.OnRelayoutSignal().Disconnect(_actorOnRelayoutEventCallbackDelegate);
- }
-
- _actorOnRelayoutEventHandler -= value;
- }
- }
- }
-
- // Callback for Actor OnRelayout signal
- private void OnRelayout(IntPtr data)
- {
- OnRelayoutEventArgs e = new OnRelayoutEventArgs();
-
- // Populate all members of "e" (OnRelayoutEventArgs) with real data
- e.Actor = Actor.GetActorFromPtr(data);
-
- if (_actorOnRelayoutEventHandler != null)
- {
- //here we send all data to user event handlers
- _actorOnRelayoutEventHandler(this, e);
- }
- }
-
public static Actor GetActorFromPtr(global::System.IntPtr cPtr) {
Actor ret = new Actor(cPtr, false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
}
- public bool Vibility
+ public bool Visibility
{
get
{
{
SetOpacity(value);
}
- }
-
- public float CurrentOpacity
- {
get
{
float ret = GetCurrentOpacity();
return ret;
}
- }
+ }
public bool StateFocusEnable
{
}
}
+ public void Show()
+ {
+ SetVisible(true);
+ }
+
+ public void Hide()
+ {
+ SetVisible(false);
+ }
+
public class Property : global::System.IDisposable {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
}
}
+ public AlphaFunction(Dali.Constants.AlphaFunction.BuiltinFunction function) : this(NDalicPINVOKE.new_AlphaFunction__SWIG_1((int)function), true){
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
public AlphaFunction() : this(NDalicPINVOKE.new_AlphaFunction__SWIG_0(), true) {
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
}
+ public static readonly int ParentOrigin = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_get();
+ public static readonly int ParentOriginX = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_X_get();
+ public static readonly int ParentOriginY = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_Y_get();
+ public static readonly int ParentOriginZ = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_Z_get();
+ public static readonly int AnchorPoint = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_get();
+ public static readonly int AnchorPointX = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_X_get();
+ public static readonly int AnchorPointY = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_Y_get();
+ public static readonly int AnchorPointZ = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_Z_get();
+ public static readonly int Size = NDalicPINVOKE.Actor_Property_SIZE_get();
+ public static readonly int SizeWidth = NDalicPINVOKE.Actor_Property_SIZE_WIDTH_get();
+ public static readonly int SizeHeight = NDalicPINVOKE.Actor_Property_SIZE_HEIGHT_get();
+ public static readonly int SizeDepth = NDalicPINVOKE.Actor_Property_SIZE_DEPTH_get();
+ public static readonly int Position = NDalicPINVOKE.Actor_Property_POSITION_get();
+ public static readonly int PositionX = NDalicPINVOKE.Actor_Property_POSITION_X_get();
+ public static readonly int PositionY = NDalicPINVOKE.Actor_Property_POSITION_Y_get();
+ public static readonly int PositionZ = NDalicPINVOKE.Actor_Property_POSITION_Z_get();
+ public static readonly int WorldPosition = NDalicPINVOKE.Actor_Property_WORLD_POSITION_get();
+ public static readonly int WorldPositionX = NDalicPINVOKE.Actor_Property_WORLD_POSITION_X_get();
+ public static readonly int WorldPositionY = NDalicPINVOKE.Actor_Property_WORLD_POSITION_Y_get();
+ public static readonly int WorldPositionZ = NDalicPINVOKE.Actor_Property_WORLD_POSITION_Z_get();
+ public static readonly int Orientation = NDalicPINVOKE.Actor_Property_ORIENTATION_get();
+ public static readonly int WorldOrientation = NDalicPINVOKE.Actor_Property_WORLD_ORIENTATION_get();
+ public static readonly int Scale = NDalicPINVOKE.Actor_Property_SCALE_get();
+ public static readonly int ScaleX = NDalicPINVOKE.Actor_Property_SCALE_X_get();
+ public static readonly int ScaleY = NDalicPINVOKE.Actor_Property_SCALE_Y_get();
+ public static readonly int ScaleZ = NDalicPINVOKE.Actor_Property_SCALE_Z_get();
+ public static readonly int WorldScale = NDalicPINVOKE.Actor_Property_WORLD_SCALE_get();
+ public static readonly int Visibile = NDalicPINVOKE.Actor_Property_VISIBLE_get();
+ public static readonly int Color = NDalicPINVOKE.Actor_Property_COLOR_get();
+ public static readonly int ColorRed = NDalicPINVOKE.Actor_Property_COLOR_RED_get();
+ public static readonly int ColorGreeb = NDalicPINVOKE.Actor_Property_COLOR_GREEN_get();
+ public static readonly int ColorBlue = NDalicPINVOKE.Actor_Property_COLOR_BLUE_get();
+ public static readonly int ColorAlpha = NDalicPINVOKE.Actor_Property_COLOR_ALPHA_get();
+ public static readonly int WorldColor = NDalicPINVOKE.Actor_Property_WORLD_COLOR_get();
+ public static readonly int WorldMatrix = NDalicPINVOKE.Actor_Property_WORLD_MATRIX_get();
+ public static readonly int Name = NDalicPINVOKE.Actor_Property_NAME_get();
+ public static readonly int Sensitive = NDalicPINVOKE.Actor_Property_SENSITIVE_get();
+ public static readonly int LeaveRequired = NDalicPINVOKE.Actor_Property_LEAVE_REQUIRED_get();
+ public static readonly int InheritOrientation = NDalicPINVOKE.Actor_Property_INHERIT_ORIENTATION_get();
+ public static readonly int InheritScale = NDalicPINVOKE.Actor_Property_INHERIT_SCALE_get();
+ public static readonly int ColorMode = NDalicPINVOKE.Actor_Property_COLOR_MODE_get();
+ public static readonly int PositionInheritance = NDalicPINVOKE.Actor_Property_POSITION_INHERITANCE_get();
+ public static readonly int DrawMode = NDalicPINVOKE.Actor_Property_DRAW_MODE_get();
+ public static readonly int SizeModeFactor = NDalicPINVOKE.Actor_Property_SIZE_MODE_FACTOR_get();
+ public static readonly int WidthResizePolicy = NDalicPINVOKE.Actor_Property_WIDTH_RESIZE_POLICY_get();
+ public static readonly int HeightResizePolicy = NDalicPINVOKE.Actor_Property_HEIGHT_RESIZE_POLICY_get();
+ public static readonly int SizeScalePolicy = NDalicPINVOKE.Actor_Property_SIZE_SCALE_POLICY_get();
+ public static readonly int WidthForHeight = NDalicPINVOKE.Actor_Property_WIDTH_FOR_HEIGHT_get();
+ public static readonly int HeightForWidth = NDalicPINVOKE.Actor_Property_HEIGHT_FOR_WIDTH_get();
+ public static readonly int Padding = NDalicPINVOKE.Actor_Property_PADDING_get();
+ public static readonly int MinimumSize = NDalicPINVOKE.Actor_Property_MINIMUM_SIZE_get();
+ public static readonly int MaximumSize = NDalicPINVOKE.Actor_Property_MAXIMUM_SIZE_get();
+ public static readonly int InheritPosition = NDalicPINVOKE.Actor_Property_INHERIT_POSITION_get();
+ public static readonly int ClippingMode = NDalicPINVOKE.Actor_Property_CLIPPING_MODE_get();
+ public static readonly int BatchParent = NDalicPINVOKE.Actor_Property_BATCH_PARENT_get();
+
+
/**
* @brief Event arguments that passed via Finished signal
*
}
}
+ public int DurationMilliSecs
+ {
+ set
+ {
+ SetDuration(value/1000);
+ }
+ get
+ {
+ int ret = (int) GetDuration() * 1000;
+ return ret;
+ }
+ }
+
public AlphaFunction DefaultAlphaFunction
{
set
}
}
+ public int LoopCount
+ {
+ set
+ {
+ SetLoopCount(value);
+ }
+ get
+ {
+ int ret = GetLoopCount();
+ return ret;
+ }
+ }
+
+ public bool Looping
+ {
+ set
+ {
+ SetLooping(value);
+ }
+ get
+ {
+ bool ret = IsLooping();
+ return ret;
+ }
+ }
+
+ public void AnimateBy<T,U>(Actor target, T propertyIndex, U relativeValue)
+ {
+ dynamic var = (object)(propertyIndex);
+ dynamic obj = (object)(relativeValue);
+ AnimateBy(new Property(target, var), new Property.Value(obj));
+ }
+
+ public void AnimateBy<T,U>(Actor target, T propertyIndex, U relativeValue, AlphaFunction alpha)
+ {
+ dynamic var = (object)(propertyIndex);
+ dynamic obj = (object)(relativeValue);
+ AnimateBy(new Property(target, var), new Property.Value(obj), alpha);
+ }
+
+ public void AnimateBy<T,U>(Actor target, T propertyIndex, U relativeValue, TimePeriod period)
+ {
+ dynamic var = (object)(propertyIndex);
+ dynamic obj = (object)(relativeValue);
+ AnimateBy(new Property(target, var), new Property.Value(obj), period);
+ }
+
+ public void AnimateBy<T,U>(Actor target, T propertyIndex, U relativeValue, AlphaFunction alpha, TimePeriod period)
+ {
+ dynamic var = (object)(propertyIndex);
+ dynamic obj = (object)(relativeValue);
+ AnimateBy(new Property(target, var), new Property.Value(obj), alpha, period);
+ }
+
+ public void AnimateTo<T,U>(Actor target, T propertyIndex, U destinationValue)
+ {
+ dynamic var = (object)(propertyIndex);
+ dynamic obj = (object)(destinationValue);
+ AnimateTo(new Property(target, var), new Property.Value(obj));
+ }
+
+ public void AnimateTo<T,U>(Actor target, T propertyIndex, U destinationValue, AlphaFunction alpha)
+ {
+ dynamic var = (object)(propertyIndex);
+ dynamic obj = (object)(destinationValue);
+ AnimateTo(new Property(target, var), new Property.Value(obj), alpha);
+ }
+
+ public void AnimateTo<T,U>(Actor target, T propertyIndex, U destinationValue, TimePeriod period)
+ {
+ dynamic var = (object)(propertyIndex);
+ dynamic obj = (object)(destinationValue);
+ AnimateTo(new Property(target, var), new Property.Value(obj), period);
+ }
+
+ public void AnimateTo<T,U>(Actor target, T propertyIndex, U destinationValue, AlphaFunction alpha, TimePeriod period)
+ {
+ dynamic var = (object)(propertyIndex);
+ dynamic obj = (object)(destinationValue);
+ AnimateTo(new Property(target, var), new Property.Value(obj), alpha, period);
+ }
+
+ public void AnimateBetween<U>(Actor target, U propertyIndex, KeyFrames keyFrames)
+ {
+ dynamic var = (object)(propertyIndex);
+ AnimateBetween(new Property(target, var), keyFrames);
+ }
+
+ public void AnimateBetween<U>(Actor target, U propertyIndex, KeyFrames keyFrames, Animation.Interpolation interpolation)
+ {
+ dynamic var = (object)(propertyIndex);
+ AnimateBetween(new Property(target, var), keyFrames, interpolation);
+ }
+
+ public void AnimateBetween<U>(Actor target, U propertyIndex, KeyFrames keyFrames, AlphaFunction alpha)
+ {
+ dynamic var = (object)(propertyIndex);
+ AnimateBetween(new Property(target, var), keyFrames, alpha);
+ }
+
+ public void AnimateBetween<U>(Actor target, U propertyIndex, KeyFrames keyFrames, AlphaFunction alpha, Animation.Interpolation interpolation)
+ {
+ dynamic var = (object)(propertyIndex);
+ AnimateBetween(new Property(target, var), keyFrames, alpha, interpolation);
+ }
+
+ public void AnimateBetween<U>(Actor target, U propertyIndex, KeyFrames keyFrames, TimePeriod period)
+ {
+ dynamic var = (object)(propertyIndex);
+ AnimateBetween(new Property(target, var), keyFrames, period);
+ }
+
+ public void AnimateBetween<U>(Actor target, U propertyIndex, KeyFrames keyFrames, TimePeriod period, Animation.Interpolation interpolation)
+ {
+ dynamic var = (object)(propertyIndex);
+ AnimateBetween(new Property(target, var), keyFrames, period, interpolation);
+ }
+
+ public void AnimateBetween<U>(Actor target, U propertyIndex, KeyFrames keyFrames, AlphaFunction alpha, TimePeriod period)
+ {
+ dynamic var = (object)(propertyIndex);
+ AnimateBetween(new Property(target, var), keyFrames, alpha, period);
+ }
+
+ public void AnimateBetween<U>(Actor target, U propertyIndex, KeyFrames keyFrames, AlphaFunction alpha, TimePeriod period, Animation.Interpolation interpolation)
+ {
+ dynamic var = (object)(propertyIndex);
+ AnimateBetween(new Property(target, var), keyFrames, alpha, period, interpolation);
+ }
+
+ public void Stop(Animation.EndAction action) {
+ SetEndAction(action);
+ NDalicPINVOKE.Animation_Stop(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ /**
+ * @brief Create an initialized Animation.
+ *
+ * The animation will not loop.
+ * The default end action is "Bake".
+ * The default Alpha function is linear.
+ * @since 1.0.0
+ * @param [in] durationmSeconds The duration in milli seconds (int).
+ * @return A handle to a newly allocated Dali resource.
+ * @pre DurationmSeconds must be greater than zero.
+ */
+ public Animation (int durationmSeconds) : this (NDalicPINVOKE.Animation_New((float)durationmSeconds/1000.0f), true) {
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
public Animation (float durationSeconds) : this (NDalicPINVOKE.Animation_New(durationSeconds), true) {
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
--- /dev/null
+//------------------------------------------------------------------------------
+// <auto-generated />
+//
+// This file was automatically generated by SWIG (http://www.swig.org).
+// Version 3.0.9
+//
+// Do not make changes to this file unless you know what you are doing--modify
+// the SWIG interface file instead.
+//------------------------------------------------------------------------------
+
+namespace Dali {
+
+public class ApplicationExtensions : global::System.IDisposable {
+ private global::System.Runtime.InteropServices.HandleRef swigCPtr;
+ protected bool swigCMemOwn;
+
+ internal ApplicationExtensions(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(ApplicationExtensions obj) {
+ return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
+ }
+
+ ~ApplicationExtensions() {
+ Dispose();
+ }
+
+ public virtual void Dispose() {
+ lock(this) {
+ if (swigCPtr.Handle != global::System.IntPtr.Zero) {
+ if (swigCMemOwn) {
+ swigCMemOwn = false;
+ NDalicPINVOKE.delete_ApplicationExtensions(swigCPtr);
+ }
+ swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
+ }
+ global::System.GC.SuppressFinalize(this);
+ }
+ }
+
+ public ApplicationExtensions() : this(NDalicPINVOKE.new_ApplicationExtensions__SWIG_0(), true) {
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public ApplicationExtensions(Application application) : this(NDalicPINVOKE.new_ApplicationExtensions__SWIG_1(Application.getCPtr(application)), true) {
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void Init() {
+ NDalicPINVOKE.ApplicationExtensions_Init(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void Terminate() {
+ NDalicPINVOKE.ApplicationExtensions_Terminate(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void Pause() {
+ NDalicPINVOKE.ApplicationExtensions_Pause(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void Resume() {
+ NDalicPINVOKE.ApplicationExtensions_Resume(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void LanguageChange() {
+ NDalicPINVOKE.ApplicationExtensions_LanguageChange(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+}
+
+}
}
- public static bool operator true(BaseHandle handle)
- {
- if( handle!= null )
- {
- return handle.IsHandleEmpty();
- }
- else
- {
- return false;
- }
- }
- public static bool operator false(BaseHandle handle)
- {
- return handle.IsHandleEmpty();
- }
+ // Returns the bool value true to indicate that an operand is true and returns false otherwise.
+ public static bool operator true(BaseHandle handle)
+ {
+ // if the C# object is null, return false
+ if( BaseHandle.ReferenceEquals( handle, null ) )
+ {
+ return false;
+ }
+ // returns true if the handle has a body, false otherwise
+ return handle.HasBody();
+ }
+
+ // Returns the bool false to indicate that an operand is false and returns true otherwise.
+ public static bool operator false(BaseHandle handle)
+ {
+ // if the C# object is null, return true
+ if( BaseHandle.ReferenceEquals( handle, null ) )
+ {
+ return true;
+ }
+ return !handle.HasBody();
+ }
+
+ // Explicit conversion from Handle to bool.
+ public static explicit operator bool(BaseHandle handle)
+ {
+ // if the C# object is null, return false
+ if( BaseHandle.ReferenceEquals( handle, null ) )
+ {
+ return false;
+ }
+ // returns true if the handle has a body, false otherwise
+ return handle.HasBody();
+ }
+
+ // Equality operator
+ public static bool operator == (BaseHandle x, BaseHandle y)
+ {
+ // if the C# objects are the same return true
+ if( BaseHandle.ReferenceEquals( x, y ) )
+ {
+ return true;
+ }
+ if ( !BaseHandle.ReferenceEquals( x, null ) && !BaseHandle.ReferenceEquals( y, null ) )
+ {
+ // drop into native code to see if both handles point to the same body
+ return x.IsEqual( y) ;
+ }
+ return false;
+
+ }
+
+ // Inequality operator. Returns Null if either operand is Null
+ public static bool operator !=(BaseHandle x, BaseHandle y)
+ {
+ return !(x==y);
+ }
+
+ // Logical AND operator for &&
+ // It's possible when doing a && this function (opBitwiseAnd) is never called due
+ // to short circuiting. E.g.
+ // If you perform x && y What actually is called is
+ // BaseHandle.op_False( x ) ? BaseHandle.op_True( x ) : BaseHandle.opTrue( BaseHandle.opBitwiseAnd(x,y) )
+ //
+ public static BaseHandle operator &(BaseHandle x, BaseHandle y)
+ {
+ if( x == y )
+ {
+ return x;
+ }
+ return null;
+ }
+
+ // Logical OR operator for ||
+ // It's possible when doing a || this function (opBitwiseOr) is never called due
+ // to short circuiting. E.g.
+ // If you perform x || y What actually is called is
+ // BaseHandle.op_True( x ) ? BaseHandle.op_True( x ) : BaseHandle.opTrue( BaseHandle.opBitwiseOr(x,y) )
+ public static BaseHandle operator |(BaseHandle x, BaseHandle y)
+ {
+ if ( !BaseHandle.ReferenceEquals( x, null ) || !BaseHandle.ReferenceEquals( y, null ) )
+ {
+ if( x.HasBody() )
+ {
+ return x;
+ }
+ if( y.HasBody() )
+ {
+ return y;
+ }
+ return null;
+ }
+ return null;
+ }
+
+ // Logical ! operator
+ public static bool operator !(BaseHandle x)
+ {
+ // if the C# object is null, return true
+ if( BaseHandle.ReferenceEquals( x, null ) )
+ {
+ return true;
+ }
+ if( x.HasBody() )
+ {
+ return false;
+ }
+ return true;
+ }
+
public BaseHandle(BaseObject handle) : this(NDalicPINVOKE.new_BaseHandle__SWIG_0(BaseObject.getCPtr(handle)), true) {
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- public bool IsHandleEmpty() {
- bool ret = NDalicPINVOKE.BaseHandle_IsHandleEmpty(swigCPtr);
+ public bool HasBody() {
+ bool ret = NDalicPINVOKE.BaseHandle_HasBody(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public bool IsEqual(BaseHandle rhs) {
+ bool ret = NDalicPINVOKE.BaseHandle_IsEqual(swigCPtr, BaseHandle.getCPtr(rhs));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
if (_buttonClickedEventHandler != null)
{
//here we send all data to user event handlers
- return _buttonClickedEventHandler(this, e,true);
+ return _buttonClickedEventHandler(this, e);
}
return false;
}
if (_buttonPressedEventHandler != null)
{
//here we send all data to user event handlers
- return _buttonPressedEventHandler(this, e,true);
+ return _buttonPressedEventHandler(this, e);
}
return false;
}
if (_buttonReleasedEventHandler != null)
{
//here we send all data to user event handlers
- return _buttonReleasedEventHandler(this, e, true);
+ return _buttonReleasedEventHandler(this, e);
}
return false;
}
if (_buttonStateChangedEventHandler != null)
{
//here we send all data to user event handlers
- return _buttonStateChangedEventHandler(this, e, true);
+ return _buttonStateChangedEventHandler(this, e);
}
return false;
}
--- /dev/null
+//------------------------------------------------------------------------------
+// <auto-generated />
+//
+// This file was automatically generated by SWIG (http://www.swig.org).
+// Version 3.0.9
+//
+// Do not make changes to this file unless you know what you are doing--modify
+// the SWIG interface file instead.
+//------------------------------------------------------------------------------
+
+namespace Dali {
+
+public class KeyInputFocusManager : BaseHandle {
+ private global::System.Runtime.InteropServices.HandleRef swigCPtr;
+
+ internal KeyInputFocusManager(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.KeyInputFocusManager_SWIGUpcast(cPtr), cMemoryOwn) {
+ swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
+ }
+
+ internal static global::System.Runtime.InteropServices.HandleRef getCPtr(KeyInputFocusManager obj) {
+ return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
+ }
+
+ ~KeyInputFocusManager() {
+ Dispose();
+ }
+
+ public override void Dispose() {
+ lock(this) {
+ if (swigCPtr.Handle != global::System.IntPtr.Zero) {
+ if (swigCMemOwn) {
+ swigCMemOwn = false;
+ NDalicPINVOKE.delete_KeyInputFocusManager(swigCPtr);
+ }
+ swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
+ }
+ global::System.GC.SuppressFinalize(this);
+ base.Dispose();
+ }
+ }
+
+ public KeyInputFocusManager() : this(NDalicPINVOKE.new_KeyInputFocusManager(), true) {
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public static KeyInputFocusManager Get() {
+ KeyInputFocusManager ret = new KeyInputFocusManager(NDalicPINVOKE.KeyInputFocusManager_Get(), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void SetFocus(View control) {
+ NDalicPINVOKE.KeyInputFocusManager_SetFocus(swigCPtr, View.getCPtr(control));
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public View GetCurrentFocusControl() {
+ View ret = new View(NDalicPINVOKE.KeyInputFocusManager_GetCurrentFocusControl(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void RemoveFocus(View control) {
+ NDalicPINVOKE.KeyInputFocusManager_RemoveFocus(swigCPtr, View.getCPtr(control));
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public bool IsKeyboardListener(View control) {
+ bool ret = NDalicPINVOKE.KeyInputFocusManager_IsKeyboardListener(swigCPtr, View.getCPtr(control));
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public SWIGTYPE_p_Dali__SignalT_void_fDali__Toolkit__Control_Dali__Toolkit__ControlF_t KeyInputFocusChangedSignal() {
+ SWIGTYPE_p_Dali__SignalT_void_fDali__Toolkit__Control_Dali__Toolkit__ControlF_t ret = new SWIGTYPE_p_Dali__SignalT_void_fDali__Toolkit__Control_Dali__Toolkit__ControlF_t(NDalicPINVOKE.KeyInputFocusManager_KeyInputFocusChangedSignal(swigCPtr), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public KeyEventSignal UnhandledKeyEventSignal() {
+ KeyEventSignal ret = new KeyEventSignal(NDalicPINVOKE.KeyInputFocusManager_UnhandledKeyEventSignal(swigCPtr), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+}
+
+}
public static readonly int IMAGE_VISUAL_DESIRED_HEIGHT = NDalicPINVOKE.IMAGE_VISUAL_DESIRED_HEIGHT_get();
public static readonly int IMAGE_VISUAL_SYNCHRONOUS_LOADING = NDalicPINVOKE.IMAGE_VISUAL_SYNCHRONOUS_LOADING_get();
public static readonly int IMAGE_VISUAL_BORDER_ONLY = NDalicPINVOKE.IMAGE_VISUAL_BORDER_ONLY_get();
- public static readonly int BATCHING_ENABLED = NDalicPINVOKE.BATCHING_ENABLED_get();
- public static readonly int PIXEL_AREA = NDalicPINVOKE.PIXEL_AREA_get();
- public static readonly int WRAP_MODE_U = NDalicPINVOKE.WRAP_MODE_U_get();
- public static readonly int WRAP_MODE_V = NDalicPINVOKE.WRAP_MODE_V_get();
+ public static readonly int IMAGE_VISUAL_BATCHING_ENABLED = NDalicPINVOKE.IMAGE_VISUAL_BATCHING_ENABLED_get();
+ public static readonly int IMAGE_VISUAL_PIXEL_AREA = NDalicPINVOKE.IMAGE_VISUAL_PIXEL_AREA_get();
+ public static readonly int IMAGE_VISUAL_WRAP_MODE_U = NDalicPINVOKE.IMAGE_VISUAL_WRAP_MODE_U_get();
+ public static readonly int IMAGE_VISUAL_WRAP_MODE_V = NDalicPINVOKE.IMAGE_VISUAL_WRAP_MODE_V_get();
public static readonly int OBJECT_URL = NDalicPINVOKE.OBJECT_URL_get();
public static readonly int MATERIAL_URL = NDalicPINVOKE.MATERIAL_URL_get();
public static readonly int BEVEL_SMOOTHNESS = NDalicPINVOKE.BEVEL_SMOOTHNESS_get();
public static readonly int PRIMITIVE_VISUAL_LIGHT_POSITION = NDalicPINVOKE.PRIMITIVE_VISUAL_LIGHT_POSITION_get();
+ public static readonly int RENDERING_BACKEND = NDalicPINVOKE.RENDERING_BACKEND_get();
+ public static readonly int TEXT = NDalicPINVOKE.TEXT_get();
+ public static readonly int FONT_FAMILY = NDalicPINVOKE.FONT_FAMILY_get();
+ public static readonly int FONT_STYLE = NDalicPINVOKE.FONT_STYLE_get();
+ public static readonly int POINT_SIZE = NDalicPINVOKE.POINT_SIZE_get();
+ public static readonly int MULTI_LINE = NDalicPINVOKE.MULTI_LINE_get();
+ public static readonly int HORIZONTAL_ALIGNMENT = NDalicPINVOKE.HORIZONTAL_ALIGNMENT_get();
+ public static readonly int VERTICAL_ALIGNMENT = NDalicPINVOKE.VERTICAL_ALIGNMENT_get();
+ public static readonly int TEXT_COLOR = NDalicPINVOKE.TEXT_COLOR_get();
+ public static readonly int ENABLE_MARKUP = NDalicPINVOKE.ENABLE_MARKUP_get();
+ public static readonly int ENABLE_AUTO_SCROLL = NDalicPINVOKE.ENABLE_AUTO_SCROLL_get();
+ public static readonly int AUTO_SCROLL_SPEED = NDalicPINVOKE.AUTO_SCROLL_SPEED_get();
+ public static readonly int AUTO_SCROLL_LOOP_COUNT = NDalicPINVOKE.AUTO_SCROLL_LOOP_COUNT_get();
+ public static readonly int AUTO_SCROLL_GAP = NDalicPINVOKE.AUTO_SCROLL_GAP_get();
+ public static readonly int LINE_SPACING = NDalicPINVOKE.LINE_SPACING_get();
+ public static readonly int UNDERLINE = NDalicPINVOKE.UNDERLINE_get();
+ public static readonly int SHADOW = NDalicPINVOKE.SHADOW_get();
+ public static readonly int EMBOSS = NDalicPINVOKE.EMBOSS_get();
+ public static readonly int OUTLINE = NDalicPINVOKE.OUTLINE_get();
+ public static readonly int BATCHING_ENABLED = NDalicPINVOKE.BATCHING_ENABLED_get();
+
}
}
[global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_Property_Array_PushBack")]
public static extern void Property_Array_PushBack(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_Property_Array_Add")]
+ public static extern global::System.IntPtr Property_Array_Add(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);
+
[global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_Property_Array_GetElementAt__SWIG_0")]
public static extern global::System.IntPtr Property_Array_GetElementAt__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2);
[global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_BaseHandle_GetObjectPtr")]
public static extern global::System.IntPtr BaseHandle_GetObjectPtr(global::System.Runtime.InteropServices.HandleRef jarg1);
- [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_BaseHandle_IsHandleEmpty")]
- public static extern bool BaseHandle_IsHandleEmpty(global::System.Runtime.InteropServices.HandleRef jarg1);
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_BaseHandle_HasBody")]
+ public static extern bool BaseHandle_HasBody(global::System.Runtime.InteropServices.HandleRef jarg1);
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_BaseHandle_IsEqual")]
+ public static extern bool BaseHandle_IsEqual(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);
[global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_LessThan__SWIG_3")]
public static extern bool LessThan__SWIG_3(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);
[global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_DragAndDropDetector_DroppedSignal")]
public static extern global::System.IntPtr DragAndDropDetector_DroppedSignal(global::System.Runtime.InteropServices.HandleRef jarg1);
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_new_ApplicationExtensions__SWIG_0")]
+ public static extern global::System.IntPtr new_ApplicationExtensions__SWIG_0();
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_new_ApplicationExtensions__SWIG_1")]
+ public static extern global::System.IntPtr new_ApplicationExtensions__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1);
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_delete_ApplicationExtensions")]
+ public static extern void delete_ApplicationExtensions(global::System.Runtime.InteropServices.HandleRef jarg1);
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_ApplicationExtensions_Init")]
+ public static extern void ApplicationExtensions_Init(global::System.Runtime.InteropServices.HandleRef jarg1);
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_ApplicationExtensions_Terminate")]
+ public static extern void ApplicationExtensions_Terminate(global::System.Runtime.InteropServices.HandleRef jarg1);
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_ApplicationExtensions_Pause")]
+ public static extern void ApplicationExtensions_Pause(global::System.Runtime.InteropServices.HandleRef jarg1);
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_ApplicationExtensions_Resume")]
+ public static extern void ApplicationExtensions_Resume(global::System.Runtime.InteropServices.HandleRef jarg1);
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_ApplicationExtensions_LanguageChange")]
+ public static extern void ApplicationExtensions_LanguageChange(global::System.Runtime.InteropServices.HandleRef jarg1);
+
[global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_Window_New__SWIG_0")]
public static extern global::System.IntPtr Window_New__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1, string jarg2, bool jarg3);
[global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get")]
public static extern int IMAGE_VISUAL_BORDER_ONLY_get();
- [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_BATCHING_ENABLED_get")]
- public static extern int BATCHING_ENABLED_get();
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_IMAGE_VISUAL_BATCHING_ENABLED_get")]
+ public static extern int IMAGE_VISUAL_BATCHING_ENABLED_get();
- [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_PIXEL_AREA_get")]
- public static extern int PIXEL_AREA_get();
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get")]
+ public static extern int IMAGE_VISUAL_PIXEL_AREA_get();
- [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_WRAP_MODE_U_get")]
- public static extern int WRAP_MODE_U_get();
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get")]
+ public static extern int IMAGE_VISUAL_WRAP_MODE_U_get();
- [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_WRAP_MODE_V_get")]
- public static extern int WRAP_MODE_V_get();
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get")]
+ public static extern int IMAGE_VISUAL_WRAP_MODE_V_get();
[global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_OBJECT_URL_get")]
public static extern int OBJECT_URL_get();
[global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get")]
public static extern int PRIMITIVE_VISUAL_LIGHT_POSITION_get();
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_RENDERING_BACKEND_get")]
+ public static extern int RENDERING_BACKEND_get();
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_TEXT_get")]
+ public static extern int TEXT_get();
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_FONT_FAMILY_get")]
+ public static extern int FONT_FAMILY_get();
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_FONT_STYLE_get")]
+ public static extern int FONT_STYLE_get();
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_POINT_SIZE_get")]
+ public static extern int POINT_SIZE_get();
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_MULTI_LINE_get")]
+ public static extern int MULTI_LINE_get();
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_HORIZONTAL_ALIGNMENT_get")]
+ public static extern int HORIZONTAL_ALIGNMENT_get();
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_VERTICAL_ALIGNMENT_get")]
+ public static extern int VERTICAL_ALIGNMENT_get();
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_TEXT_COLOR_get")]
+ public static extern int TEXT_COLOR_get();
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_ENABLE_MARKUP_get")]
+ public static extern int ENABLE_MARKUP_get();
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_ENABLE_AUTO_SCROLL_get")]
+ public static extern int ENABLE_AUTO_SCROLL_get();
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_AUTO_SCROLL_SPEED_get")]
+ public static extern int AUTO_SCROLL_SPEED_get();
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_AUTO_SCROLL_LOOP_COUNT_get")]
+ public static extern int AUTO_SCROLL_LOOP_COUNT_get();
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_AUTO_SCROLL_GAP_get")]
+ public static extern int AUTO_SCROLL_GAP_get();
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_LINE_SPACING_get")]
+ public static extern int LINE_SPACING_get();
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_UNDERLINE_get")]
+ public static extern int UNDERLINE_get();
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_SHADOW_get")]
+ public static extern int SHADOW_get();
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_EMBOSS_get")]
+ public static extern int EMBOSS_get();
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_OUTLINE_get")]
+ public static extern int OUTLINE_get();
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_BATCHING_ENABLED_get")]
+ public static extern int BATCHING_ENABLED_get();
+
[global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_new_Builder")]
public static extern global::System.IntPtr new_Builder();
[global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_Builder_QuitSignal")]
public static extern global::System.IntPtr Builder_QuitSignal(global::System.Runtime.InteropServices.HandleRef jarg1);
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_new_TransitionData__SWIG_0")]
+ public static extern global::System.IntPtr new_TransitionData__SWIG_0();
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_delete_TransitionData")]
+ public static extern void delete_TransitionData(global::System.Runtime.InteropServices.HandleRef jarg1);
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_TransitionData_New__SWIG_0")]
+ public static extern global::System.IntPtr TransitionData_New__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1);
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_TransitionData_New__SWIG_1")]
+ public static extern global::System.IntPtr TransitionData_New__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1);
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_TransitionData_DownCast")]
+ public static extern global::System.IntPtr TransitionData_DownCast(global::System.Runtime.InteropServices.HandleRef jarg1);
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_new_TransitionData__SWIG_1")]
+ public static extern global::System.IntPtr new_TransitionData__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1);
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_TransitionData_Assign")]
+ public static extern global::System.IntPtr TransitionData_Assign(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_TransitionData_Count")]
+ public static extern uint TransitionData_Count(global::System.Runtime.InteropServices.HandleRef jarg1);
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_TransitionData_GetAnimatorAt")]
+ public static extern global::System.IntPtr TransitionData_GetAnimatorAt(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2);
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_new_TransitionData__SWIG_2")]
+ public static extern global::System.IntPtr new_TransitionData__SWIG_2(global::System.Runtime.InteropServices.HandleRef jarg1);
+
[global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_ViewImpl_New")]
public static extern global::System.IntPtr ViewImpl_New();
[global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_new_View__SWIG_2")]
public static extern global::System.IntPtr new_View__SWIG_2(global::System.Runtime.InteropServices.HandleRef jarg1);
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_new_KeyInputFocusManager")]
+ public static extern global::System.IntPtr new_KeyInputFocusManager();
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_delete_KeyInputFocusManager")]
+ public static extern void delete_KeyInputFocusManager(global::System.Runtime.InteropServices.HandleRef jarg1);
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_KeyInputFocusManager_Get")]
+ public static extern global::System.IntPtr KeyInputFocusManager_Get();
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_KeyInputFocusManager_SetFocus")]
+ public static extern void KeyInputFocusManager_SetFocus(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl")]
+ public static extern global::System.IntPtr KeyInputFocusManager_GetCurrentFocusControl(global::System.Runtime.InteropServices.HandleRef jarg1);
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_KeyInputFocusManager_RemoveFocus")]
+ public static extern void KeyInputFocusManager_RemoveFocus(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_KeyInputFocusManager_IsKeyboardListener")]
+ public static extern bool KeyInputFocusManager_IsKeyboardListener(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal")]
+ public static extern global::System.IntPtr KeyInputFocusManager_KeyInputFocusChangedSignal(global::System.Runtime.InteropServices.HandleRef jarg1);
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_KeyInputFocusManager_UnhandledKeyEventSignal")]
+ public static extern global::System.IntPtr KeyInputFocusManager_UnhandledKeyEventSignal(global::System.Runtime.InteropServices.HandleRef jarg1);
+
[global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_new_Alignment_Padding__SWIG_0")]
public static extern global::System.IntPtr new_Alignment_Padding__SWIG_0();
[global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_VisualBase_Assign")]
public static extern global::System.IntPtr VisualBase_Assign(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_VisualBase_SetName")]
+ public static extern void VisualBase_SetName(global::System.Runtime.InteropServices.HandleRef jarg1, string jarg2);
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_VisualBase_GetName")]
+ public static extern string VisualBase_GetName(global::System.Runtime.InteropServices.HandleRef jarg1);
+
[global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_VisualBase_SetSize")]
public static extern void VisualBase_SetSize(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);
[global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_VisualBase_GetSize")]
public static extern global::System.IntPtr VisualBase_GetSize(global::System.Runtime.InteropServices.HandleRef jarg1);
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_VisualBase_GetHeightForWidth")]
+ public static extern float VisualBase_GetHeightForWidth(global::System.Runtime.InteropServices.HandleRef jarg1, float jarg2);
+
[global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_VisualBase_GetNaturalSize")]
public static extern void VisualBase_GetNaturalSize(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);
[global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_VisualBase_GetDepthIndex")]
public static extern float VisualBase_GetDepthIndex(global::System.Runtime.InteropServices.HandleRef jarg1);
- [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_VisualBase_SetOnStage")]
- public static extern void VisualBase_SetOnStage(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);
-
- [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_VisualBase_SetOffStage")]
- public static extern void VisualBase_SetOffStage(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);
-
- [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_VisualBase_RemoveAndReset")]
- public static extern void VisualBase_RemoveAndReset(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);
-
[global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_VisualBase_CreatePropertyMap")]
public static extern void VisualBase_CreatePropertyMap(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_VisualBase_SetProperty")]
+ public static extern void VisualBase_SetProperty(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3);
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_VisualBase_GetProperty")]
+ public static extern global::System.IntPtr VisualBase_GetProperty(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);
+
[global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_new_VisualBase__SWIG_2")]
public static extern global::System.IntPtr new_VisualBase__SWIG_2(global::System.Runtime.InteropServices.HandleRef jarg1);
[global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_Builder_SWIGUpcast")]
public static extern global::System.IntPtr Builder_SWIGUpcast(global::System.IntPtr jarg1);
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_TransitionData_SWIGUpcast")]
+ public static extern global::System.IntPtr TransitionData_SWIGUpcast(global::System.IntPtr jarg1);
+
[global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_ViewImpl_SWIGUpcast")]
public static extern global::System.IntPtr ViewImpl_SWIGUpcast(global::System.IntPtr jarg1);
[global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_View_SWIGUpcast")]
public static extern global::System.IntPtr View_SWIGUpcast(global::System.IntPtr jarg1);
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_KeyInputFocusManager_SWIGUpcast")]
+ public static extern global::System.IntPtr KeyInputFocusManager_SWIGUpcast(global::System.IntPtr jarg1);
+
[global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_Alignment_SWIGUpcast")]
public static extern global::System.IntPtr Alignment_SWIGUpcast(global::System.IntPtr jarg1);
return ret;
}
- public virtual Image NewPage(uint pageId) {
- Image ret = new Image(NDalicPINVOKE.PageFactory_NewPage(swigCPtr, pageId), true);
+ public virtual Texture NewPage(uint pageId) {
+ Texture ret = new Texture(NDalicPINVOKE.PageFactory_NewPage(swigCPtr, pageId), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ public Property.Array Add(Property.Value value) {
+ Property.Array ret = new Property.Array(NDalicPINVOKE.Property_Array_Add(swigCPtr, Property.Value.getCPtr(value)), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
public Property.Value GetElementAt(uint index) {
Property.Value ret = new Property.Value(NDalicPINVOKE.Property_Array_GetElementAt__SWIG_0(swigCPtr, index), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
}
+
+ public int X {
+ set {
+ NDalicPINVOKE.RectInteger_x_set(swigCPtr, value);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+ get {
+ int ret = NDalicPINVOKE.RectInteger_x_get(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+ }
+
+ public int Y {
+ set {
+ NDalicPINVOKE.RectInteger_y_set(swigCPtr, value);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+ get {
+ int ret = NDalicPINVOKE.RectInteger_y_get(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+ }
+
+ public int W {
+ set {
+ NDalicPINVOKE.RectInteger_width_set(swigCPtr, value);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+ get {
+ int ret = NDalicPINVOKE.RectInteger_width_get(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+ }
+
+ public int H {
+ set {
+ NDalicPINVOKE.RectInteger_height_set(swigCPtr, value);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+ get {
+ int ret = NDalicPINVOKE.RectInteger_height_get(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+ }
+
+
public RectInteger() : this(NDalicPINVOKE.new_RectInteger__SWIG_0(), true) {
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
--- /dev/null
+//------------------------------------------------------------------------------
+// <auto-generated />
+//
+// This file was automatically generated by SWIG (http://www.swig.org).
+// Version 3.0.9
+//
+// Do not make changes to this file unless you know what you are doing--modify
+// the SWIG interface file instead.
+//------------------------------------------------------------------------------
+
+namespace Dali {
+
+public class SWIGTYPE_p_Dali__SignalT_void_fDali__Toolkit__Control_Dali__Toolkit__ControlF_t {
+ private global::System.Runtime.InteropServices.HandleRef swigCPtr;
+
+ internal SWIGTYPE_p_Dali__SignalT_void_fDali__Toolkit__Control_Dali__Toolkit__ControlF_t(global::System.IntPtr cPtr, bool futureUse) {
+ swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
+ }
+
+ protected SWIGTYPE_p_Dali__SignalT_void_fDali__Toolkit__Control_Dali__Toolkit__ControlF_t() {
+ swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
+ }
+
+ internal static global::System.Runtime.InteropServices.HandleRef getCPtr(SWIGTYPE_p_Dali__SignalT_void_fDali__Toolkit__Control_Dali__Toolkit__ControlF_t obj) {
+ return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
+ }
+}
+
+}
--- /dev/null
+//------------------------------------------------------------------------------
+// <auto-generated />
+//
+// This file was automatically generated by SWIG (http://www.swig.org).
+// Version 3.0.9
+//
+// Do not make changes to this file unless you know what you are doing--modify
+// the SWIG interface file instead.
+//------------------------------------------------------------------------------
+
+namespace Dali {
+
+public class SWIGTYPE_p_Dali__Toolkit__Internal__TransitionData {
+ private global::System.Runtime.InteropServices.HandleRef swigCPtr;
+
+ internal SWIGTYPE_p_Dali__Toolkit__Internal__TransitionData(global::System.IntPtr cPtr, bool futureUse) {
+ swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
+ }
+
+ protected SWIGTYPE_p_Dali__Toolkit__Internal__TransitionData() {
+ swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
+ }
+
+ internal static global::System.Runtime.InteropServices.HandleRef getCPtr(SWIGTYPE_p_Dali__Toolkit__Internal__TransitionData obj) {
+ return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
+ }
+}
+
+}
if (_sliderValueChangedEventHandler != null)
{
//here we send all page to user event handlers
- return _sliderValueChangedEventHandler(this, e, true);
+ return _sliderValueChangedEventHandler(this, e);
}
return false;
}
if (_sliderSlidingFinishedEventHandler != null)
{
//here we send all page to user event handlers
- return _sliderSlidingFinishedEventHandler(this, e, true);
+ return _sliderSlidingFinishedEventHandler(this, e);
}
return false;
}
if (_sliderMarkReachedEventHandler != null)
{
//here we send all page to user event handlers
- return _sliderMarkReachedEventHandler(this, e, true);
+ return _sliderMarkReachedEventHandler(this, e);
}
return false;
}
}
}
- public Vector2 Size
+ ///< name "Size", type Dali.Size (Stage Size value)
+ //@since 1.0.0
+ public Dali.Size Size
{
get
{
- Vector2 ret = GetSize();
+ Vector2 ret1 = GetSize();
+ Dali.Size ret= new Size(ret1);
return ret;
}
}
- public Vector4 BackgroundColor
+ ///< name "BackgroundColor", type Dali.Color (Stage background color value)
+ //@since 1.0.0
+ public Dali.Color BackgroundColor
{
set
{
}
get
{
- Vector4 ret = GetBackgroundColor();
+ Vector4 ret1 = GetBackgroundColor();
+ Dali.Color ret = new Color(ret1);
return ret;
}
}
SetProperty( TextEditor.Property.FONT_FAMILY, new Dali.Property.Value( value ) );
}
}
- public string FontStyle
+ public Dali.Property.Map FontStyle
{
get
{
- string temp;
- GetProperty( TextEditor.Property.FONT_STYLE).Get( out temp );
+ Dali.Property.Map temp = new Dali.Property.Map();
+ GetProperty( TextEditor.Property.FONT_STYLE).Get( temp );
return temp;
}
set
SetProperty( TextEditor.Property.INPUT_FONT_FAMILY, new Dali.Property.Value( value ) );
}
}
- public string InputFontStyle
+ public Dali.Property.Map InputFontStyle
{
get
{
- string temp;
- GetProperty( TextEditor.Property.INPUT_FONT_STYLE).Get( out temp );
+ Dali.Property.Map temp = new Dali.Property.Map();
+ GetProperty( TextEditor.Property.INPUT_FONT_STYLE).Get( temp );
return temp;
}
set
SetProperty( TextEditor.Property.INPUT_LINE_SPACING, new Dali.Property.Value( value ) );
}
}
- public string Underline
+ public Dali.Property.Map Underline
{
get
{
- string temp;
- GetProperty( TextEditor.Property.UNDERLINE).Get( out temp );
+ Dali.Property.Map temp = new Dali.Property.Map();
+ GetProperty( TextEditor.Property.UNDERLINE).Get( temp );
return temp;
}
set
SetProperty( TextEditor.Property.UNDERLINE, new Dali.Property.Value( value ) );
}
}
- public string InputUnderline
+ public Dali.Property.Map InputUnderline
{
get
{
- string temp;
- GetProperty( TextEditor.Property.INPUT_UNDERLINE).Get( out temp );
+ Dali.Property.Map temp = new Dali.Property.Map();
+ GetProperty( TextEditor.Property.INPUT_UNDERLINE).Get( temp );
return temp;
}
set
SetProperty( TextEditor.Property.INPUT_UNDERLINE, new Dali.Property.Value( value ) );
}
}
- public string Shadow
+ public Dali.Property.Map Shadow
{
get
{
- string temp;
- GetProperty( TextEditor.Property.SHADOW).Get( out temp );
+ Dali.Property.Map temp = new Dali.Property.Map();
+ GetProperty( TextEditor.Property.SHADOW).Get( temp );
return temp;
}
set
SetProperty( TextEditor.Property.SHADOW, new Dali.Property.Value( value ) );
}
}
- public string InputShadow
+ public Dali.Property.Map InputShadow
{
get
{
- string temp;
- GetProperty( TextEditor.Property.INPUT_SHADOW).Get( out temp );
+ Dali.Property.Map temp = new Dali.Property.Map();
+ GetProperty( TextEditor.Property.INPUT_SHADOW).Get( temp );
return temp;
}
set
SetProperty( TextEditor.Property.INPUT_SHADOW, new Dali.Property.Value( value ) );
}
}
- public string Emboss
+ public Dali.Property.Map Emboss
{
get
{
- string temp;
- GetProperty( TextEditor.Property.EMBOSS).Get( out temp );
+ Dali.Property.Map temp = new Dali.Property.Map();
+ GetProperty( TextEditor.Property.EMBOSS).Get( temp );
return temp;
}
set
SetProperty( TextEditor.Property.EMBOSS, new Dali.Property.Value( value ) );
}
}
- public string InputEmboss
+ public Dali.Property.Map InputEmboss
{
get
{
- string temp;
- GetProperty( TextEditor.Property.INPUT_EMBOSS).Get( out temp );
+ Dali.Property.Map temp = new Dali.Property.Map();
+ GetProperty( TextEditor.Property.INPUT_EMBOSS).Get( temp );
return temp;
}
set
SetProperty( TextEditor.Property.INPUT_EMBOSS, new Dali.Property.Value( value ) );
}
}
- public string Outline
+ public Dali.Property.Map Outline
{
get
{
- string temp;
- GetProperty( TextEditor.Property.OUTLINE).Get( out temp );
+ Dali.Property.Map temp = new Dali.Property.Map();
+ GetProperty( TextEditor.Property.OUTLINE).Get( temp );
return temp;
}
set
SetProperty( TextEditor.Property.OUTLINE, new Dali.Property.Value( value ) );
}
}
- public string InputOutline
+ public Dali.Property.Map InputOutline
{
get
{
- string temp;
- GetProperty( TextEditor.Property.INPUT_OUTLINE).Get( out temp );
+ Dali.Property.Map temp = new Dali.Property.Map();
+ GetProperty( TextEditor.Property.INPUT_OUTLINE).Get( temp );
return temp;
}
set
SetProperty( TextField.Property.FONT_FAMILY, new Dali.Property.Value( value ) );
}
}
- public string FontStyle
+ public Dali.Property.Map FontStyle
{
get
{
- string temp;
- GetProperty( TextField.Property.FONT_STYLE).Get( out temp );
+ Dali.Property.Map temp = new Dali.Property.Map();
+ GetProperty( TextField.Property.FONT_STYLE).Get( temp );
return temp;
}
set
SetProperty( TextField.Property.INPUT_FONT_FAMILY, new Dali.Property.Value( value ) );
}
}
- public string InputFontStyle
+ public Dali.Property.Map InputFontStyle
{
get
{
- string temp;
- GetProperty( TextField.Property.INPUT_FONT_STYLE).Get( out temp );
+ Dali.Property.Map temp = new Dali.Property.Map();
+ GetProperty( TextField.Property.INPUT_FONT_STYLE).Get( temp );
return temp;
}
set
SetProperty( TextField.Property.INPUT_POINT_SIZE, new Dali.Property.Value( value ) );
}
}
- public string Underline
+ public Dali.Property.Map Underline
{
get
{
- string temp;
- GetProperty( TextField.Property.UNDERLINE).Get( out temp );
+ Dali.Property.Map temp = new Dali.Property.Map();
+ GetProperty( TextField.Property.UNDERLINE).Get( temp );
return temp;
}
set
SetProperty( TextField.Property.UNDERLINE, new Dali.Property.Value( value ) );
}
}
- public string InputUnderline
+ public Dali.Property.Map InputUnderline
{
get
{
- string temp;
- GetProperty( TextField.Property.INPUT_UNDERLINE).Get( out temp );
+ Dali.Property.Map temp = new Dali.Property.Map();
+ GetProperty( TextField.Property.INPUT_UNDERLINE).Get( temp );
return temp;
}
set
SetProperty( TextField.Property.INPUT_UNDERLINE, new Dali.Property.Value( value ) );
}
}
- public string Shadow
+ public Dali.Property.Map Shadow
{
get
{
- string temp;
- GetProperty( TextField.Property.SHADOW).Get( out temp );
+ Dali.Property.Map temp = new Dali.Property.Map();
+ GetProperty( TextField.Property.SHADOW).Get( temp );
return temp;
}
set
SetProperty( TextField.Property.SHADOW, new Dali.Property.Value( value ) );
}
}
- public string InputShadow
+ public Dali.Property.Map InputShadow
{
get
{
- string temp;
- GetProperty( TextField.Property.INPUT_SHADOW).Get( out temp );
+ Dali.Property.Map temp = new Dali.Property.Map();
+ GetProperty( TextField.Property.INPUT_SHADOW).Get( temp );
return temp;
}
set
SetProperty( TextField.Property.INPUT_SHADOW, new Dali.Property.Value( value ) );
}
}
- public string Emboss
+ public Dali.Property.Map Emboss
{
get
{
- string temp;
- GetProperty( TextField.Property.EMBOSS).Get( out temp );
+ Dali.Property.Map temp = new Dali.Property.Map();
+ GetProperty( TextField.Property.EMBOSS).Get( temp );
return temp;
}
set
SetProperty( TextField.Property.EMBOSS, new Dali.Property.Value( value ) );
}
}
- public string InputEmboss
+ public Dali.Property.Map InputEmboss
{
get
{
- string temp;
- GetProperty( TextField.Property.INPUT_EMBOSS).Get( out temp );
+ Dali.Property.Map temp = new Dali.Property.Map();
+ GetProperty( TextField.Property.INPUT_EMBOSS).Get( temp );
return temp;
}
set
SetProperty( TextField.Property.INPUT_EMBOSS, new Dali.Property.Value( value ) );
}
}
- public string Outline
+ public Dali.Property.Map Outline
{
get
{
- string temp;
- GetProperty( TextField.Property.OUTLINE).Get( out temp );
+ Dali.Property.Map temp = new Dali.Property.Map();
+ GetProperty( TextField.Property.OUTLINE).Get( temp );
return temp;
}
set
SetProperty( TextField.Property.OUTLINE, new Dali.Property.Value( value ) );
}
}
- public string InputOutline
+ public Dali.Property.Map InputOutline
{
get
{
- string temp;
- GetProperty( TextField.Property.INPUT_OUTLINE).Get( out temp );
+ Dali.Property.Map temp = new Dali.Property.Map();
+ GetProperty( TextField.Property.INPUT_OUTLINE).Get( temp );
return temp;
}
set
SetProperty( TextLabel.Property.FONT_FAMILY, new Dali.Property.Value( value ) );
}
}
- public string FontStyle
+ public Dali.Property.Map FontStyle
{
get
{
- string temp;
- GetProperty( TextLabel.Property.FONT_STYLE).Get( out temp );
+ Dali.Property.Map temp = new Dali.Property.Map();
+ GetProperty( TextLabel.Property.FONT_STYLE).Get( temp );
return temp;
}
set
SetProperty( TextLabel.Property.LINE_SPACING, new Dali.Property.Value( value ) );
}
}
- public string Underline
+ public Dali.Property.Map Underline
{
get
{
- string temp;
- GetProperty( TextLabel.Property.UNDERLINE).Get( out temp );
+ Dali.Property.Map temp = new Dali.Property.Map();
+ GetProperty( TextLabel.Property.UNDERLINE).Get( temp );
return temp;
}
set
SetProperty( TextLabel.Property.UNDERLINE, new Dali.Property.Value( value ) );
}
}
- public string Shadow
+ public Dali.Property.Map Shadow
{
get
{
- string temp;
- GetProperty( TextLabel.Property.SHADOW).Get( out temp );
+ Dali.Property.Map temp = new Dali.Property.Map();
+ GetProperty( TextLabel.Property.SHADOW).Get( temp );
return temp;
}
set
SetProperty( TextLabel.Property.SHADOW, new Dali.Property.Value( value ) );
}
}
- public string Emboss
+ public Dali.Property.Map Emboss
{
get
{
- string temp;
- GetProperty( TextLabel.Property.EMBOSS).Get( out temp );
+ Dali.Property.Map temp = new Dali.Property.Map();
+ GetProperty( TextLabel.Property.EMBOSS).Get( temp );
return temp;
}
set
SetProperty( TextLabel.Property.EMBOSS, new Dali.Property.Value( value ) );
}
}
- public string Outline
+ public Dali.Property.Map Outline
{
get
{
- string temp;
- GetProperty( TextLabel.Property.OUTLINE).Get( out temp );
+ Dali.Property.Map temp = new Dali.Property.Map();
+ GetProperty( TextLabel.Property.OUTLINE).Get( temp );
return temp;
}
set
--- /dev/null
+/** Copyright (c) 2016 Samsung Electronics Co., Ltd.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*
+*/
+// This File has been auto-generated by SWIG and then modified using DALi Ruby Scripts
+//------------------------------------------------------------------------------
+// <auto-generated />
+//
+// This file was automatically generated by SWIG (http://www.swig.org).
+// Version 3.0.9
+//
+// Do not make changes to this file unless you know what you are doing--modify
+// the SWIG interface file instead.
+//------------------------------------------------------------------------------
+
+namespace Dali {
+
+public class TransitionData : BaseHandle {
+ private global::System.Runtime.InteropServices.HandleRef swigCPtr;
+
+ internal TransitionData(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.TransitionData_SWIGUpcast(cPtr), cMemoryOwn) {
+ swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
+ }
+
+ internal static global::System.Runtime.InteropServices.HandleRef getCPtr(TransitionData obj) {
+ return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
+ }
+
+ ~TransitionData() {
+ Dispose();
+ }
+
+ public override void Dispose() {
+ lock(this) {
+ if (swigCPtr.Handle != global::System.IntPtr.Zero) {
+ if (swigCMemOwn) {
+ swigCMemOwn = false;
+ NDalicPINVOKE.delete_TransitionData(swigCPtr);
+ }
+ swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
+ }
+ global::System.GC.SuppressFinalize(this);
+ base.Dispose();
+ }
+ }
+
+ public TransitionData (Property.Map transition) : this (NDalicPINVOKE.TransitionData_New__SWIG_0(Property.Map.getCPtr(transition)), true) {
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+
+ }
+ public TransitionData (Property.Array transition) : this (NDalicPINVOKE.TransitionData_New__SWIG_1(Property.Array.getCPtr(transition)), true) {
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+
+ }
+ public static TransitionData DownCast(BaseHandle handle) {
+ TransitionData ret = new TransitionData(NDalicPINVOKE.TransitionData_DownCast(BaseHandle.getCPtr(handle)), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public TransitionData(TransitionData handle) : this(NDalicPINVOKE.new_TransitionData__SWIG_1(TransitionData.getCPtr(handle)), true) {
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public TransitionData Assign(TransitionData handle) {
+ TransitionData ret = new TransitionData(NDalicPINVOKE.TransitionData_Assign(swigCPtr, TransitionData.getCPtr(handle)), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public uint Count() {
+ uint ret = NDalicPINVOKE.TransitionData_Count(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public Property.Map GetAnimatorAt(uint index) {
+ Property.Map ret = new Property.Map(NDalicPINVOKE.TransitionData_GetAnimatorAt(swigCPtr, index), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public TransitionData(SWIGTYPE_p_Dali__Toolkit__Internal__TransitionData impl) : this(NDalicPINVOKE.new_TransitionData__SWIG_2(SWIGTYPE_p_Dali__Toolkit__Internal__TransitionData.getCPtr(impl)), true) {
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+}
+
+}
namespace Dali {
-using System;
-using System.Runtime.InteropServices;
-
+ using System;
+ using System.Runtime.InteropServices;
+
public class View : CustomActor {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
-/**
- * @brief Event arguments that passed via KeyInputFocusGained signal
- *
- */
-public class KeyInputFocusGainedEventArgs : EventArgs
-{
- private View _view;
+ /**
+ * @brief Event arguments that passed via KeyInputFocusGained signal
+ *
+ */
+ public class KeyInputFocusGainedEventArgs : EventArgs
+ {
+ private View _view;
+
+ /**
+ * @brief View - is the view that gets Key Input Focus
+ *
+ */
+ public View View
+ {
+ get
+ {
+ return _view;
+ }
+ set
+ {
+ _view = value;
+ }
+ }
+ }
- /**
- * @brief View - is the view that gets Key Input Focus
+ /**
+ * @brief Event arguments that passed via KeyInputFocusLost signal
*
*/
- public View View
- {
- get
+ public class KeyInputFocusLostEventArgs : EventArgs
+ {
+ private View _view;
+
+ /**
+ * @brief View - is the view that loses Key Input Focus
+ *
+ */
+ public View View
{
- return _view;
+ get
+ {
+ return _view;
+ }
+ set
+ {
+ _view = value;
+ }
}
- set
+ }
+
+ /**
+ * @brief Event arguments that passed via KeyEvent signal
+ *
+ */
+ public class KeyEventArgs : EventArgs
+ {
+ private View _view;
+ private KeyEvent _keyEvent;
+
+ /**
+ * @brief View - is the view that recieves the keyevent.
+ *
+ */
+ public View View
{
- _view = value;
+ get
+ {
+ return _view;
+ }
+ set
+ {
+ _view = value;
+ }
}
- }
-}
-/**
- * @brief Event arguments that passed via KeyInputFocusLost signal
- *
- */
-public class KeyInputFocusLostEventArgs : EventArgs
-{
- private View _view;
+ /**
+ * @brief KeyEvent - is the keyevent sent to the View.
+ *
+ */
+ public KeyEvent KeyEvent
+ {
+ get
+ {
+ return _keyEvent;
+ }
+ set
+ {
+ _keyEvent = value;
+ }
+ }
+ }
- /**
- * @brief View - is the view that loses Key Input Focus
- *
+ /**
+ * @brief Event arguments that passed via OnRelayout signal
+ *
+ */
+ public class OnRelayoutEventArgs : EventArgs
+ {
+ private View _view;
+
+ /**
+ * @brief View - is the view that is being resized upon relayout
+ *
+ */
+ public View View
+ {
+ get
+ {
+ return _view;
+ }
+ set
+ {
+ _view = value;
+ }
+ }
+ }
+
+
+ /**
+ * @brief Event arguments that passed via Touch signal
+ *
+ */
+ public class TouchEventArgs : EventArgs
+ {
+ private View _view;
+ private TouchData _touchData;
+
+ /**
+ * @brief View - is the view that is being touched
+ *
+ */
+ public View View
+ {
+ get
+ {
+ return _view;
+ }
+ set
+ {
+ _view = value;
+ }
+ }
+
+ /**
+ * @brief TouchData - contains the information of touch points
+ *
+ */
+ public TouchData TouchData
+ {
+ get
+ {
+ return _touchData;
+ }
+ set
+ {
+ _touchData = value;
+ }
+ }
+ }
+
+ /**
+ * @brief Event arguments that passed via Hover signal
+ *
+ */
+ public class HoverEventArgs : EventArgs
+ {
+ private View _view;
+ private HoverEvent _hoverEvent;
+
+ /**
+ * @brief View - is the view that is being hovered
+ *
+ */
+ public View View
+ {
+ get
+ {
+ return _view;
+ }
+ set
+ {
+ _view = value;
+ }
+ }
+
+ /**
+ * @brief HoverEvent - contains touch points that represent the points
+ * that are currently being hovered or the points where a hover has stopped
+ *
+ */
+ public HoverEvent HoverEvent
+ {
+ get
+ {
+ return _hoverEvent;
+ }
+ set
+ {
+ _hoverEvent = value;
+ }
+ }
+ }
+
+ /**
+ * @brief Event arguments that passed via Wheel signal
+ *
+ */
+ public class WheelEventArgs : EventArgs
+ {
+ private View _view;
+ private WheelEvent _wheelEvent;
+
+ /**
+ * @brief View - is the view that is being wheeled
+ *
+ */
+ public View View
+ {
+ get
+ {
+ return _view;
+ }
+ set
+ {
+ _view = value;
+ }
+ }
+
+ /**
+ * @brief WheelEvent - store a wheel rolling type : MOUSE_WHEEL or CUSTOM_WHEEL
+ *
+ */
+ public WheelEvent WheelEvent
+ {
+ get
+ {
+ return _wheelEvent;
+ }
+ set
+ {
+ _wheelEvent = value;
+ }
+ }
+ }
+
+ /**
+ * @brief Event arguments that passed via OnStage signal
+ *
+ */
+ public class OnStageEventArgs : EventArgs
+ {
+ private View _view;
+
+ /**
+ * @brief View - is the view that is being connected to the stage
+ *
+ */
+ public View View
+ {
+ get
+ {
+ return _view;
+ }
+ set
+ {
+ _view = value;
+ }
+ }
+ }
+
+ /**
+ * @brief Event arguments that passed via OffStage signal
+ *
+ */
+ public class OffStageEventArgs : EventArgs
+ {
+ private View _view;
+
+ /**
+ * @brief View - is the view that is being disconnected from the stage
+ *
+ */
+ public View View
+ {
+ get
+ {
+ return _view;
+ }
+ set
+ {
+ _view = value;
+ }
+ }
+ }
+
+ [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ private delegate void KeyInputFocusGainedCallbackDelegate(IntPtr control);
+ private DaliEventHandler<object,KeyInputFocusGainedEventArgs> _KeyInputFocusGainedEventHandler;
+ private KeyInputFocusGainedCallbackDelegate _KeyInputFocusGainedCallbackDelegate;
+
+ [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ private delegate void KeyInputFocusLostCallbackDelegate(IntPtr control);
+ private DaliEventHandler<object,KeyInputFocusLostEventArgs> _KeyInputFocusLostEventHandler;
+ private KeyInputFocusLostCallbackDelegate _KeyInputFocusLostCallbackDelegate;
+
+ [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ private delegate bool KeyCallbackDelegate(IntPtr control, IntPtr keyEvent);
+ private DaliEventHandlerWithReturnType<object,KeyEventArgs,bool> _KeyEventHandler;
+ private KeyCallbackDelegate _KeyCallbackDelegate;
+
+ [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ private delegate void OnRelayoutEventCallbackDelegate(IntPtr control);
+ private DaliEventHandler<object,OnRelayoutEventArgs> _viewOnRelayoutEventHandler;
+ private OnRelayoutEventCallbackDelegate _viewOnRelayoutEventCallbackDelegate;
+
+ [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ private delegate bool TouchCallbackDelegate(IntPtr view, IntPtr touchData);
+ private DaliEventHandlerWithReturnType<object,TouchEventArgs,bool> _viewTouchDataEventHandler;
+ private TouchCallbackDelegate _viewTouchDataCallbackDelegate;
+
+ [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ private delegate bool HoverEventCallbackDelegate(IntPtr view, IntPtr hoverEvent);
+ private DaliEventHandlerWithReturnType<object,HoverEventArgs,bool> _viewHoverEventHandler;
+ private HoverEventCallbackDelegate _viewHoverEventCallbackDelegate;
+
+ [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ private delegate bool WheelEventCallbackDelegate(IntPtr view, IntPtr wheelEvent);
+ private DaliEventHandlerWithReturnType<object,WheelEventArgs,bool> _viewWheelEventHandler;
+ private WheelEventCallbackDelegate _viewWheelEventCallbackDelegate;
+
+ [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ private delegate void OnStageEventCallbackDelegate(IntPtr control);
+ private DaliEventHandler<object,OnStageEventArgs> _viewOnStageEventHandler;
+ private OnStageEventCallbackDelegate _viewOnStageEventCallbackDelegate;
+
+ [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ private delegate void OffStageEventCallbackDelegate(IntPtr control);
+ private DaliEventHandler<object,OffStageEventArgs> _viewOffStageEventHandler;
+ private OffStageEventCallbackDelegate _viewOffStageEventCallbackDelegate;
+
+ /**
+ * @brief Event for KeyInputFocusGained signal which can be used to subscribe/unsubscribe the event handler
+ * (in the type of KeyInputFocusGainedEventHandler-DaliEventHandler<object,KeyInputFocusGainedEventArgs>)
+ * provided by the user. KeyInputFocusGained signal is emitted when the control gets Key Input Focus.
*/
- public View View
- {
- get
+ public event DaliEventHandler<object,KeyInputFocusGainedEventArgs> KeyInputFocusGained
+ {
+ add
{
- return _view;
+ lock(this)
+ {
+ // Restricted to only one listener
+ if (_KeyInputFocusGainedEventHandler == null)
+ {
+ _KeyInputFocusGainedEventHandler += value;
+ Console.WriteLine("View Keyevent EVENT Locked....");
+ _KeyInputFocusGainedCallbackDelegate = new KeyInputFocusGainedCallbackDelegate(OnKeyInputFocusGained);
+ this.KeyInputFocusGainedSignal().Connect(_KeyInputFocusGainedCallbackDelegate);
+ }
+ }
}
- set
+
+ remove
{
- _view = value;
+ lock(this)
+ {
+ if (_KeyInputFocusGainedEventHandler != null)
+ {
+ this.KeyInputFocusGainedSignal().Disconnect(_KeyInputFocusGainedCallbackDelegate);
+ }
+
+ _KeyInputFocusGainedEventHandler -= value;
+ }
}
- }
-}
+ }
-/**
- * @brief Event arguments that passed via KeyEvent signal
- *
- */
-public class KeyEventArgs : EventArgs
-{
- private View _view;
- private KeyEvent _keyEvent;
-
- /**
- * @brief View - is the view that recieves the keyevent.
- *
+ private void OnKeyInputFocusGained(IntPtr view)
+ {
+ KeyInputFocusGainedEventArgs e = new KeyInputFocusGainedEventArgs();
+ Console.WriteLine("View Keyevent ....");
+ // Populate all members of "e" (KeyInputFocusGainedEventArgs) with real data
+ e.View = Dali.View.GetViewFromPtr(view);
+
+ if (_KeyInputFocusGainedEventHandler != null)
+ {
+ //here we send all data to user event handlers
+ _KeyInputFocusGainedEventHandler(this, e);
+ }
+
+ }
+
+ /**
+ * @brief Event for KeyInputFocusLost signal which can be used to subscribe/unsubscribe the event handler
+ * (in the type of KeyInputFocusLostEventHandler-DaliEventHandler<object,KeyInputFocusLostEventArgs>)
+ * provided by the user. KeyInputFocusLost signal is emitted when the control loses Key Input Focus.
*/
- public View View
- {
- get
+ public event DaliEventHandler<object,KeyInputFocusLostEventArgs> KeyInputFocusLost
+ {
+ add
{
- return _view;
+ lock(this)
+ {
+ // Restricted to only one listener
+ if (_KeyInputFocusLostEventHandler == null)
+ {
+ _KeyInputFocusLostEventHandler += value;
+
+ _KeyInputFocusLostCallbackDelegate = new KeyInputFocusLostCallbackDelegate(OnKeyInputFocusLost);
+ this.KeyInputFocusLostSignal().Connect(_KeyInputFocusLostCallbackDelegate);
+ }
+ }
}
- set
+
+ remove
{
- _view = value;
+ lock(this)
+ {
+ if (_KeyInputFocusLostEventHandler != null)
+ {
+ this.KeyInputFocusLostSignal().Disconnect(_KeyInputFocusLostCallbackDelegate);
+ }
+
+ _KeyInputFocusLostEventHandler -= value;
+ }
}
- }
+ }
- /**
- * @brief KeyEvent - is the keyevent sent to the View.
- *
+ private void OnKeyInputFocusLost(IntPtr view)
+ {
+ KeyInputFocusLostEventArgs e = new KeyInputFocusLostEventArgs();
+
+ // Populate all members of "e" (KeyInputFocusLostEventArgs) with real data
+ e.View = Dali.View.GetViewFromPtr(view);
+
+ if (_KeyInputFocusLostEventHandler != null)
+ {
+ //here we send all data to user event handlers
+ _KeyInputFocusLostEventHandler(this, e);
+ }
+ }
+
+ /**
+ * @brief Event for KeyPressed signal which can be used to subscribe/unsubscribe the event handler
+ * (in the type of KeyEventEventHandler-DaliEventHandlerWithReturnType<object,KeyEventArgs,bool>)
+ * provided by the user. KeyPressed signal is emitted when key event is received.
*/
- public KeyEvent KeyEvent
- {
- get
+ public event DaliEventHandlerWithReturnType<object,KeyEventArgs,bool> KeyPressed
+ {
+ add
{
- return _keyEvent;
+ lock(this)
+ {
+ // Restricted to only one listener
+ if (_KeyEventHandler == null)
+ {
+ _KeyEventHandler += value;
+
+ _KeyCallbackDelegate = new KeyCallbackDelegate(OnKeyEvent);
+ this.KeyEventSignal().Connect(_KeyCallbackDelegate);
+ }
+ }
}
- set
+
+ remove
{
- _keyEvent = value;
+ lock(this)
+ {
+ if (_KeyEventHandler != null)
+ {
+ this.KeyEventSignal().Disconnect(_KeyCallbackDelegate);
+ }
+
+ _KeyEventHandler -= value;
+ }
}
- }
-}
+ }
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
- private delegate void KeyInputFocusGainedCallbackDelegate(IntPtr control);
- private DaliEventHandler<object,KeyInputFocusGainedEventArgs> _KeyInputFocusGainedEventHandler;
- private KeyInputFocusGainedCallbackDelegate _KeyInputFocusGainedCallbackDelegate;
-
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
- private delegate void KeyInputFocusLostCallbackDelegate(IntPtr control);
- private DaliEventHandler<object,KeyInputFocusLostEventArgs> _KeyInputFocusLostEventHandler;
- private KeyInputFocusLostCallbackDelegate _KeyInputFocusLostCallbackDelegate;
-
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
- 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-DaliEventHandler<object,KeyInputFocusGainedEventArgs>)
- * provided by the user. KeyInputFocusGained signal is emitted when the control gets Key Input Focus.
- */
- public event DaliEventHandler<object,KeyInputFocusGainedEventArgs> KeyInputFocusGained
- {
- add
- {
+ private bool OnKeyEvent(IntPtr view, IntPtr keyEvent)
+ {
+ KeyEventArgs e = new KeyEventArgs();
+
+ // Populate all members of "e" (KeyEventArgs) with real data
+ e.View = Dali.View.GetViewFromPtr(view);
+ e.KeyEvent = Dali.KeyEvent.GetKeyEventFromPtr(keyEvent);
+
+ if (_KeyEventHandler != null)
+ {
+ //here we send all data to user event handlers
+ return _KeyEventHandler(this, e);
+ }
+ return false;
+
+ }
+
+ /**
+ * @brief Event for OnRelayout signal which can be used to subscribe/unsubscribe the event handler
+ * (in the type of OnRelayoutEventHandler) provided by the user.
+ * OnRelayout signal is emitted after the size has been set on the view during relayout.
+ */
+ public event DaliEventHandler<object,OnRelayoutEventArgs> OnRelayoutEvent
+ {
+ add
+ {
lock(this)
{
- // Restricted to only one listener
- if (_KeyInputFocusGainedEventHandler == null)
- {
- _KeyInputFocusGainedEventHandler += value;
+ // Restricted to only one listener
+ if (_viewOnRelayoutEventHandler == null)
+ {
+ _viewOnRelayoutEventHandler += value;
+ Console.WriteLine("View OnRelayoutEventArgs Locked....");
+ _viewOnRelayoutEventCallbackDelegate = new OnRelayoutEventCallbackDelegate(OnRelayout);
+ this.OnRelayoutSignal().Connect(_viewOnRelayoutEventCallbackDelegate);
+ }
+ }
+ }
+
+ remove
+ {
+ lock(this)
+ {
+ if (_viewOnRelayoutEventHandler != null)
+ {
+ this.OnRelayoutSignal().Disconnect(_viewOnRelayoutEventCallbackDelegate);
+ }
+
+ _viewOnRelayoutEventHandler -= value;
+ }
+ }
+ }
+
+ // Callback for View OnRelayout signal
+ private void OnRelayout(IntPtr data)
+ {
+ OnRelayoutEventArgs e = new OnRelayoutEventArgs();
+ Console.WriteLine("View OnRelayoutEventArgs....");
+ // Populate all members of "e" (OnRelayoutEventArgs) with real data
+ e.View = View.GetViewFromPtr(data);
+
+ if (_viewOnRelayoutEventHandler != null)
+ {
+ //here we send all data to user event handlers
+ _viewOnRelayoutEventHandler(this, e);
+ }
+ }
- _KeyInputFocusGainedCallbackDelegate = new KeyInputFocusGainedCallbackDelegate(OnKeyInputFocusGained);
- this.KeyInputFocusGainedSignal().Connect(_KeyInputFocusGainedCallbackDelegate);
- }
+ /**
+ * @brief Event for Touched signal which can be used to subscribe/unsubscribe the event handler
+ * (in the type of TouchEventHandler-DaliEventHandlerWithReturnType<object,TouchEventArgs,bool>)
+ * provided by the user. Touched signal is emitted when touch input is received.
+ */
+ public event DaliEventHandlerWithReturnType<object,TouchEventArgs,bool> Touched
+ {
+ add
+ {
+ lock(this)
+ {
+ // Restricted to only one listener
+ if (_viewTouchDataEventHandler == null)
+ {
+ _viewTouchDataEventHandler += value;
+ Console.WriteLine("View Touch EVENT LOCKED....");
+ _viewTouchDataCallbackDelegate = new TouchCallbackDelegate(OnTouch);
+ this.TouchSignal().Connect(_viewTouchDataCallbackDelegate);
+ }
}
- }
+ }
- remove
- {
+ remove
+ {
lock(this)
{
- if (_KeyInputFocusGainedEventHandler != null)
- {
- this.KeyInputFocusGainedSignal().Disconnect(_KeyInputFocusGainedCallbackDelegate);
- }
+ if (_viewTouchDataEventHandler != null)
+ {
+ this.TouchSignal().Disconnect(_viewTouchDataCallbackDelegate);
+ }
- _KeyInputFocusGainedEventHandler -= value;
+ _viewTouchDataEventHandler -= value;
}
- }
- }
+ }
+ }
+
+ // Callback for View TouchSignal
+ private bool OnTouch(IntPtr view, IntPtr touchData)
+ {
+ TouchEventArgs e = new TouchEventArgs();
+ Console.WriteLine("View Touch EVENT....");
+ // Populate all members of "e" (TouchEventArgs) with real data
+ e.View = View.GetViewFromPtr(view);
+ e.TouchData = Dali.TouchData.GetTouchDataFromPtr(touchData);
- private void OnKeyInputFocusGained(IntPtr view)
- {
- KeyInputFocusGainedEventArgs e = new KeyInputFocusGainedEventArgs();
+ if (_viewTouchDataEventHandler != null)
+ {
+ //here we send all data to user event handlers
+ return _viewTouchDataEventHandler(this, e);
+ }
- // Populate all members of "e" (KeyInputFocusGainedEventArgs) with real data
- e.View = Dali.View.GetViewFromPtr(view);
+ return false;
+ }
- if (_KeyInputFocusGainedEventHandler != null)
- {
- //here we send all data to user event handlers
- _KeyInputFocusGainedEventHandler(this, e);
- }
+ /**
+ * @brief Event for Hovered signal which can be used to subscribe/unsubscribe the event handler
+ * (in the type of HoverEventHandler-DaliEventHandlerWithReturnType<object,HoverEventArgs,bool>)
+ * provided by the user. Hovered signal is emitted when hover input is received.
+ */
+ public event DaliEventHandlerWithReturnType<object,HoverEventArgs,bool> Hovered
+ {
+ add
+ {
+ lock(this)
+ {
+ // Restricted to only one listener
+ if (_viewHoverEventHandler == null)
+ {
+ _viewHoverEventHandler += value;
- }
+ _viewHoverEventCallbackDelegate = new HoverEventCallbackDelegate(OnHoverEvent);
+ this.HoveredSignal().Connect(_viewHoverEventCallbackDelegate);
+ }
+ }
+ }
- /**
- * @brief Event for KeyInputFocusLost signal which can be used to subscribe/unsubscribe the event handler
- * (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 DaliEventHandler<object,KeyInputFocusLostEventArgs> KeyInputFocusLost
- {
- add
- {
+ remove
+ {
lock(this)
{
- // Restricted to only one listener
- if (_KeyInputFocusLostEventHandler == null)
- {
- _KeyInputFocusLostEventHandler += value;
+ if (_viewHoverEventHandler != null)
+ {
+ this.HoveredSignal().Disconnect(_viewHoverEventCallbackDelegate);
+ }
+
+ _viewHoverEventHandler -= value;
+ }
+ }
+ }
+
+ // Callback for View Hover signal
+ private bool OnHoverEvent(IntPtr view, IntPtr hoverEvent)
+ {
+ HoverEventArgs e = new HoverEventArgs();
+
+ // Populate all members of "e" (HoverEventArgs) with real data
+ e.View = View.GetViewFromPtr(view);
+ e.HoverEvent = Dali.HoverEvent.GetHoverEventFromPtr(hoverEvent);
+
+ if (_viewHoverEventHandler != null)
+ {
+ //here we send all data to user event handlers
+ return _viewHoverEventHandler(this, e);
+ }
- _KeyInputFocusLostCallbackDelegate = new KeyInputFocusLostCallbackDelegate(OnKeyInputFocusLost);
- this.KeyInputFocusLostSignal().Connect(_KeyInputFocusLostCallbackDelegate);
- }
+ return false;
+ }
+
+ /**
+ * @brief Event for WheelMoved signal which can be used to subscribe/unsubscribe the event handler
+ * (in the type of WheelEventHandler-DaliEventHandlerWithReturnType<object,WheelEventArgs,bool>)
+ * provided by the user. WheelMoved signal is emitted when wheel event is received.
+ */
+ public event DaliEventHandlerWithReturnType<object,WheelEventArgs,bool> WheelMoved
+ {
+ add
+ {
+ lock(this)
+ {
+ // Restricted to only one listener
+ if (_viewWheelEventHandler == null)
+ {
+ _viewWheelEventHandler += value;
+ Console.WriteLine("View Wheel EVENT LOCKED....");
+ _viewWheelEventCallbackDelegate = new WheelEventCallbackDelegate(OnWheelEvent);
+ this.WheelEventSignal().Connect(_viewWheelEventCallbackDelegate);
+ }
}
- }
+ }
- remove
- {
+ remove
+ {
lock(this)
{
- if (_KeyInputFocusLostEventHandler != null)
- {
- this.KeyInputFocusLostSignal().Disconnect(_KeyInputFocusLostCallbackDelegate);
- }
+ if (_viewWheelEventHandler != null)
+ {
+ this.WheelEventSignal().Disconnect(_viewWheelEventCallbackDelegate);
+ }
- _KeyInputFocusLostEventHandler -= value;
+ _viewWheelEventHandler -= value;
}
- }
- }
+ }
+ }
- private void OnKeyInputFocusLost(IntPtr view)
- {
- KeyInputFocusLostEventArgs e = new KeyInputFocusLostEventArgs();
+ // Callback for View Wheel signal
+ private bool OnWheelEvent(IntPtr view, IntPtr wheelEvent)
+ {
+ WheelEventArgs e = new WheelEventArgs();
+ Console.WriteLine("View Wheel EVENT ....");
+ // Populate all members of "e" (WheelEventArgs) with real data
+ e.View = View.GetViewFromPtr(view);
+ e.WheelEvent = Dali.WheelEvent.GetWheelEventFromPtr(wheelEvent);
- // Populate all members of "e" (KeyInputFocusLostEventArgs) with real data
- e.View = Dali.View.GetViewFromPtr(view);
+ if (_viewWheelEventHandler != null)
+ {
+ //here we send all data to user event handlers
+ return _viewWheelEventHandler(this, e);
+ }
- if (_KeyInputFocusLostEventHandler != null)
- {
- //here we send all data to user event handlers
- _KeyInputFocusLostEventHandler(this, e);
- }
- }
+ return false;
+ }
+
+ /**
+ * @brief Event for OnStage signal which can be used to subscribe/unsubscribe the event handler
+ * (in the type of OnStageEventHandler) provided by the user.
+ * OnStage signal is emitted after the view has been connected to the stage.
+ */
+ public event DaliEventHandler<object,OnStageEventArgs> OnStageEvent
+ {
+ add
+ {
+ lock(this)
+ {
+ // Restricted to only one listener
+ if (_viewOnStageEventHandler == null)
+ {
+ _viewOnStageEventHandler += value;
+
+ _viewOnStageEventCallbackDelegate = new OnStageEventCallbackDelegate(OnStage);
+ this.OnStageSignal().Connect(_viewOnStageEventCallbackDelegate);
+ }
+ }
+ }
- /**
- * @brief Event for KeyPressed signal which can be used to subscribe/unsubscribe the event handler
- * (in the type of KeyEventEventHandler-DaliEventHandlerWithReturnType<object,KeyEventArgs,bool>)
- * provided by the user. KeyPressed signal is emitted when key event is received.
- */
- public event DaliEventHandlerWithReturnType<object,KeyEventArgs,bool> KeyPressed
- {
- add
- {
+ remove
+ {
lock(this)
{
- // Restricted to only one listener
- if (_KeyEventHandler == null)
- {
- _KeyEventHandler += value;
+ if (_viewOnStageEventHandler != null)
+ {
+ this.OnStageSignal().Disconnect(_viewOnStageEventCallbackDelegate);
+ }
- _KeyCallbackDelegate = new KeyCallbackDelegate(OnKeyEvent);
- this.KeyEventSignal().Connect(_KeyCallbackDelegate);
- }
+ _viewOnStageEventHandler -= value;
}
- }
+ }
+ }
+
+ // Callback for View OnStage signal
+ private void OnStage(IntPtr data)
+ {
+ OnStageEventArgs e = new OnStageEventArgs();
- remove
- {
+ // Populate all members of "e" (OnStageEventArgs) with real data
+ e.View = View.GetViewFromPtr(data);
+
+ if (_viewOnStageEventHandler != null)
+ {
+ //here we send all data to user event handlers
+ _viewOnStageEventHandler(this, e);
+ }
+ }
+
+ /**
+ * @brief Event for OffStage signal which can be used to subscribe/unsubscribe the event handler
+ * (in the type of OffStageEventHandler) provided by the user.
+ * OffStage signal is emitted after the view has been disconnected from the stage.
+ */
+ public event DaliEventHandler<object,OffStageEventArgs> OffStageEvent
+ {
+ add
+ {
lock(this)
{
- if (_KeyEventHandler != null)
- {
- this.KeyEventSignal().Disconnect(_KeyCallbackDelegate);
- }
+ // Restricted to only one listener
+ if (_viewOffStageEventHandler == null)
+ {
+ _viewOffStageEventHandler += value;
- _KeyEventHandler -= value;
+ _viewOffStageEventCallbackDelegate = new OffStageEventCallbackDelegate(OffStage);
+ this.OnStageSignal().Connect(_viewOffStageEventCallbackDelegate);
+ }
}
- }
- }
+ }
- private bool OnKeyEvent(IntPtr view, IntPtr keyEvent)
- {
- KeyEventArgs e = new KeyEventArgs();
+ remove
+ {
+ lock(this)
+ {
+ if (_viewOffStageEventHandler != null)
+ {
+ this.OnStageSignal().Disconnect(_viewOffStageEventCallbackDelegate);
+ }
- // Populate all members of "e" (KeyEventArgs) with real data
- e.View = Dali.View.GetViewFromPtr(view);
- e.KeyEvent = Dali.KeyEvent.GetKeyEventFromPtr(keyEvent);
+ _viewOffStageEventHandler -= value;
+ }
+ }
+ }
- if (_KeyEventHandler != null)
- {
- //here we send all data to user event handlers
- return _KeyEventHandler(this, e, true);
- }
- return false;
+ // Callback for View OffStage signal
+ private void OffStage(IntPtr data)
+ {
+ OffStageEventArgs e = new OffStageEventArgs();
- }
+ // Populate all members of "e" (OffStageEventArgs) with real data
+ e.View = View.GetViewFromPtr(data);
- public static View GetViewFromPtr(global::System.IntPtr cPtr) {
- View ret = new View(cPtr, false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
+ if (_viewOffStageEventHandler != null)
+ {
+ //here we send all data to user event handlers
+ _viewOffStageEventHandler(this, e);
+ }
+ }
+ 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 class Property : global::System.IDisposable {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
protected bool swigCMemOwn;
CONTROL_PROPERTY_END_INDEX = CONTROL_PROPERTY_START_INDEX+1000
}
+ public string StyleName
+ {
+ get
+ {
+ string temp;
+ GetProperty( View.Property.STYLE_NAME).Get( out temp );
+ return temp;
+ }
+ set
+ {
+ SetProperty( View.Property.STYLE_NAME, new Dali.Property.Value( value ) );
+ }
+ }
+ public Vector4 BackgroundColor
+ {
+ get
+ {
+ Vector4 temp = new Vector4(0.0f,0.0f,0.0f,0.0f);
+ GetProperty( View.Property.BACKGROUND_COLOR).Get( temp );
+ return temp;
+ }
+ set
+ {
+ SetProperty( View.Property.BACKGROUND_COLOR, new Dali.Property.Value( value ) );
+ }
+ }
+ public Dali.Property.Map BackgroundImage
+ {
+ get
+ {
+ Dali.Property.Map temp = new Dali.Property.Map();
+ GetProperty( View.Property.BACKGROUND_IMAGE).Get( temp );
+ return temp;
+ }
+ set
+ {
+ SetProperty( View.Property.BACKGROUND_IMAGE, new Dali.Property.Value( value ) );
+ }
+ }
+ public bool KeyInputFocus
+ {
+ get
+ {
+ bool temp = false;
+ GetProperty( View.Property.KEY_INPUT_FOCUS).Get( ref temp );
+ return temp;
+ }
+ set
+ {
+ SetProperty( View.Property.KEY_INPUT_FOCUS, new Dali.Property.Value( value ) );
+ }
+ }
+ public Dali.Property.Map Background
+ {
+ get
+ {
+ Dali.Property.Map temp = new Dali.Property.Map();
+ GetProperty( View.Property.BACKGROUND).Get( temp );
+ return temp;
+ }
+ set
+ {
+ SetProperty( View.Property.BACKGROUND, new Dali.Property.Value( value ) );
+ }
+ }
+
+ public Vector2 CellIndex
+ {
+ get
+ {
+ Vector2 temp = new Vector2(0.0f,0.0f);
+ GetProperty( TableView.ChildProperty.CELL_INDEX).Get( temp );
+ return temp;
+ }
+ set
+ {
+ SetProperty( TableView.ChildProperty.CELL_INDEX, new Dali.Property.Value( value ) );
+ }
+ }
+ public float RowSpan
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty( TableView.ChildProperty.ROW_SPAN).Get( ref temp );
+ return temp;
+ }
+ set
+ {
+ SetProperty( TableView.ChildProperty.ROW_SPAN, new Dali.Property.Value( value ) );
+ }
+ }
+ public float ColumnSpan
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty( TableView.ChildProperty.COLUMN_SPAN).Get( ref temp );
+ return temp;
+ }
+ set
+ {
+ SetProperty( TableView.ChildProperty.COLUMN_SPAN, new Dali.Property.Value( value ) );
+ }
+ }
+ public string CellHorizontalAlignment
+ {
+ get
+ {
+ string temp;
+ GetProperty( TableView.ChildProperty.CELL_HORIZONTAL_ALIGNMENT).Get( out temp );
+ return temp;
+ }
+ set
+ {
+ SetProperty( TableView.ChildProperty.CELL_HORIZONTAL_ALIGNMENT, new Dali.Property.Value( value ) );
+ }
+ }
+ public string CellVerticalAlignment
+ {
+ get
+ {
+ string temp;
+ GetProperty( TableView.ChildProperty.CELL_VERTICAL_ALIGNMENT).Get( out temp );
+ return temp;
+ }
+ set
+ {
+ SetProperty( TableView.ChildProperty.CELL_VERTICAL_ALIGNMENT, new Dali.Property.Value( value ) );
+ }
+ }
+
+ public float Flex
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty( FlexContainer.ChildProperty.FLEX).Get( ref temp );
+ return temp;
+ }
+ set
+ {
+ SetProperty( FlexContainer.ChildProperty.FLEX, new Dali.Property.Value( value ) );
+ }
+ }
+ public int AlignSelf
+ {
+ get
+ {
+ int temp = 0;
+ GetProperty( FlexContainer.ChildProperty.ALIGN_SELF).Get( ref temp );
+ return temp;
+ }
+ set
+ {
+ SetProperty( FlexContainer.ChildProperty.ALIGN_SELF, new Dali.Property.Value( value ) );
+ }
+ }
+ public Vector4 FlexMargin
+ {
+ get
+ {
+ Vector4 temp = new Vector4(0.0f,0.0f,0.0f,0.0f);
+ GetProperty( FlexContainer.ChildProperty.FLEX_MARGIN).Get( temp );
+ return temp;
+ }
+ set
+ {
+ SetProperty( FlexContainer.ChildProperty.FLEX_MARGIN, new Dali.Property.Value( value ) );
+ }
+ }
+
}
}
return ret;
}
+ public void SetName(string name) {
+ NDalicPINVOKE.VisualBase_SetName(swigCPtr, name);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public string GetName() {
+ string ret = NDalicPINVOKE.VisualBase_GetName(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
public void SetSize(Vector2 size) {
NDalicPINVOKE.VisualBase_SetSize(swigCPtr, Vector2.getCPtr(size));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
+ public float GetHeightForWidth(float width) {
+ float ret = NDalicPINVOKE.VisualBase_GetHeightForWidth(swigCPtr, width);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
public void GetNaturalSize(Vector2 naturalSize) {
NDalicPINVOKE.VisualBase_GetNaturalSize(swigCPtr, Vector2.getCPtr(naturalSize));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- public void SetOnStage(Actor actor) {
- NDalicPINVOKE.VisualBase_SetOnStage(swigCPtr, Actor.getCPtr(actor));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public void SetOffStage(Actor actor) {
- NDalicPINVOKE.VisualBase_SetOffStage(swigCPtr, Actor.getCPtr(actor));
+ public void CreatePropertyMap(Property.Map map) {
+ NDalicPINVOKE.VisualBase_CreatePropertyMap(swigCPtr, Property.Map.getCPtr(map));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public void RemoveAndReset(Actor actor) {
- NDalicPINVOKE.VisualBase_RemoveAndReset(swigCPtr, Actor.getCPtr(actor));
+ public void SetProperty(int index, Property.Value propertyValue) {
+ NDalicPINVOKE.VisualBase_SetProperty(swigCPtr, index, Property.Value.getCPtr(propertyValue));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public void CreatePropertyMap(Property.Map map) {
- NDalicPINVOKE.VisualBase_CreatePropertyMap(swigCPtr, Property.Map.getCPtr(map));
+ public Property.Value GetProperty(int index) {
+ Property.Value ret = new Property.Value(NDalicPINVOKE.VisualBase_GetProperty(swigCPtr, index), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
}
public VisualBase(SWIGTYPE_p_Dali__Toolkit__Internal__Visual__Base impl) : this(NDalicPINVOKE.new_VisualBase__SWIG_2(SWIGTYPE_p_Dali__Toolkit__Internal__Visual__Base.getCPtr(impl)), true) {
IMAGE,
MESH,
PRIMITIVE,
- WIREFRAME
+ WIREFRAME,
+ TEXT
}
}
using System;
+
+public enum Colors
+{
+ Red,
+ White,
+ Blue,
+ Green,
+ Black,
+ Grey,
+ Yellow,
+ Azure,
+ Rose
+}
+
+
+
public class Color : Vector4
{
/**
break;
}
}
+
+
+ /**
+ * @brief constructor
+ *
+ * @since 1.0.0
+ * @param [in] color as enum Colors.
+ */
+ public Color(Colors color)
+ : base(0, 0, 0, 0)
+ {
+ switch (color)
+ {
+ case Colors.Red:
+ SetColor(255, 0, 0, 255);
+ break;
+ case Colors.White:
+ SetColor(255, 255, 255, 255);
+ break;
+ case Colors.Blue:
+ SetColor(0, 0, 255, 255);
+ break;
+ case Colors.Green:
+ SetColor(0, 255, 0, 255);
+ break;
+ case Colors.Black:
+ SetColor(0, 0, 0, 255);
+ break;
+ case Colors.Grey:
+ SetColor(128, 128, 128, 255);
+ break;
+ case Colors.Yellow:
+ SetColor(255, 255, 0, 255);
+ break;
+ case Colors.Azure:
+ SetColor(0, 255, 255, 255);
+ break;
+ case Colors.Rose:
+ SetColor(255, 0, 255, 255);
+ break;
+ }
+ }
+
/**
* @brief SetColor
projects / platform / core / uifw / dali-toolkit.git / commitdiff